Beheer tabelcellen in presentaties met C++

Overzicht

Aspose.Slides stelt u in staat om tabelcellen in PowerPoint‑presentaties te benaderen en te wijzigen. Dit artikel legt uit hoe u samengevoegde tabelcellen kunt identificeren, celranden kunt verwijderen, kunt werken met celnummering na het samenvoegen of splitsen van cellen, de achtergrondkleur van een cel kunt wijzigen, en een afbeelding in een tabelcel kunt toevoegen. De voorbeelden laten zien hoe u een presentatie maakt of opent, een tabel van een dia haalt, de opmaak van cellen bijwerkt via cel‑eigenschappen, en de gewijzigde presentatie opslaat als een PPTX‑bestand.

Aspose.Slides gebruikt nul‑gebaseerde indexen om tabelcellen te benaderen in de volgorde (column, row).

Identificeer een samengevoegde tabelcel

Het voorbeeld opent een bestaande presentatie en benadert de eerste vorm op de eerste dia als een tabel. Het gaat ervan uit dat de dia en de vorm bestaan en dat de vorm een tabel is. Vervolgens doorloopt het alle rijen en kolommen en gebruikt get_IsMergedCell om cellen in samengevoegde gebieden te identificeren. Voor elke overeenkomst drukt het de celcoördinaten af in de volgorde row;column, get_RowSpan, get_ColSpan, en de startcoördinaten van het gebied, get_FirstRowIndex en 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());
        }
    }
}

Tabelcelranden verwijderen

Maak een Presentation aan en voeg een tabel toe aan de eerste dia met AddTable. De kolombreedtes, rijhoogtes en de positie van de tabel worden opgegeven in punten. Het voorbeeld stelt alle vier de celranden in op FillType::NoFill, waardoor ze onzichtbaar worden.

#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);

Diagonale celranden toevoegen

Gebruik get_BorderDiagonalDown om een lijn te tekenen van de linkerbovenhoek naar de rechteronderhoek, en get_BorderDiagonalUp om een lijn te tekenen van de linksonderhoek naar de rechterbovenhoek. Een diagonale lijn kan een hoekkop markeren; beide diagonalen kunnen een X vormen om een cel als niet‑toepasselijk te markeren.

Elke diagonale lijn is een ILineFormat. Gebruik get_FillFormat om de vulling te benaderen, roep set_FillType aan met FillType::Solid en kies een kleur via get_SolidFillColor. Stel de lijndikte in met set_Width in punten.

Het voorbeeld maakt drie cellen in één rij: een rode diagonale lijn naar beneden, een blauwe diagonale lijn naar boven, en beide diagonalen. Het laat de boven‑, onder‑, linker‑ en rechtercelranden ongewijzigd.

#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);

Een diagonale lijn is een opmaak‑eigenschap, geen cel‑splitsing. Elke cel behoudt één tekstframe dat benaderd wordt via get_TextFrame; de gebieden aan beide zijden van een diagonale lijn kunnen niet onafhankelijk worden bewerkt.

De opgeslagen tabel, gerenderd in Microsoft PowerPoint: Drie tabelcellen die een rode diagonale lijn van links‑boven naar rechts‑onder tonen, een blauwe diagonale lijn van links‑onder naar rechts‑boven, en beide diagonalen vormen een X.

Van links naar rechts: diagonale lijn naar beneden (rood, 3 pt), diagonale lijn naar boven (blauw, 5 pt), en beide diagonalen.

Tabelcellen samenvoegen

Gebruik MergeCells om een rechthoekig bereik van tabelcellen te combineren tot één cel. Specificeer de cellen in de linkerboven‑ en rechteronderhoek van het bereik. Het laatste argument bepaalt of het samenvoegen ook cellen buiten het opgegeven bereik mag omvatten; false houdt het samenvoegen binnen dat bereik.

Het voorbeeld maakt een 4‑bij‑4 tabel met kolommen en rijen van 70 punten, en voegt vervolgens de vier centrale cellen van (1, 1) tot en met (2, 2) samen. De resulterende cel beslaat twee kolommen en twee rijen, terwijl het onderliggende raster van de tabel vier kolommen en vier rijen behoudt. Om de inhoud of opmaak van de samengevoegde cel te benaderen, gebruik je de linkerboven‑positie: table->idx_get(1, 1) in dit voorbeeld. De andere posities in het samengevoegde bereik blijven deel uitmaken van het tabelraster, dus de indexen van cellen buiten het bereik wijzigen niet.

#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);

Tabelcellen splitsen

Het samenvoegen van cellen in het vorige voorbeeld behoudt het raster van de tabel. Het splitsen van een cel kan een nieuwe rasterkolom introduceren en de kolomindexen van de cellen rechts ervan wijzigen. Aspose.Slides volgt het tabelrastermodel van PowerPoint.

Dit voorbeeld maakt een 4‑bij‑4 tabel met kolommen en rijen van 70 punten en roept SplitByWidth aan op cel (1, 1). De helft van de 70‑punt breedte van de cel wordt gebruikt om twee even brede cellen te maken.

Na deze splitsing worden de twee helften benaderd als table->idx_get(1, 1) en table->idx_get(2, 1). Het tabelraster heeft nu vijf kolommen: cellen die oorspronkelijk in kolom 2 en 3 stonden, verplaatsen zich naar kolom 3 en 4, respectievelijk. Rij‑indexen blijven ongewijzigd. Gebruik deze bijgewerkte kolomindexen bij het benaderen van cellen na de splitsing.

#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);

Een niet‑samengevoegde cel van 70 punten splitst in twee cellen van 35 punten, waardoor een vijfde rasterkolom wordt toegevoegd en de indexen er rechts van verschuiven.

De breedtesplitsing beïnvloedt cel (1, 1), met nul‑gebaseerde (kolom, rij) indexen. Andere rijen behouden een cel die beide nieuwe kolomposities beslaat.

Samengevoegde cellen splitsen op rij‑ of kolom‑span

Om samengevoegde sjablooncellen voor gegevensvulling voor te bereiden, gebruik je SplitByRowSpan om langs een bestaande rijscheiding te splitsen, of SplitByColSpan om langs een kolomscheiding te splitsen.

Het argument index telt rijen in het bovenste deel of kolommen in het linkerdeel van de splitsing; het is relatief ten opzichte van het samengevoegde gebied:

Het voorbeeld gaat ervan uit dat een presentatie een tabel heeft als de eerste vorm op de eerste dia, waarbij (1, 2) en (1, 3) verticaal zijn samengevoegd. Beginnend vanaf de onderste positie gebruikt het get_FirstColumnIndex en get_FirstRowIndex om de oorsprong te vinden en controleert beide spans. SplitByRowSpan(1) splitst vervolgens rijen 2 en 3 voor productnamen. Voor een horizontale samengevoegde van twee kolommen, gebruik 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);

    // Haal de resulterende cellen uit de tabel op na het splitsen.
    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.");
}

Het tabelraster en de omliggende celindexen blijven ongewijzigd. Haal de resulterende cellen op via hun coördinaten; hier hebben beide een span van 1 en get_IsMergedCell geeft False weer. Grotere gebieden kunnen deels samengevoegd blijven na één splitsing.

De oorspronkelijke tekst en opmaak blijven in de bovenste (of linker) cel; de nieuwe cel is leeg maar erft de celopmaak zoals vulling, randen en marges. Vul de cellen na het splitsen en stel eventuele benodigde tekstopmaak expliciet in.

De opgeslagen presentatie bevat afzonderlijke “Product A”‑ en “Product B”‑cellen met de sjabloon‑celopmaak behouden. Zie de Cell API Reference voor details.

Een cel splitsen op een specifieke hoogte

SplitByHeight neemt de hoogte van het bovenste deel in punten. SplitByRowSpan neemt het aantal bestaande rasterrijen in het bovenste deel. Om een cel van 40 punten te centreren in de rechter kolom, trek je 40 af van de werkelijke hoogte van de cel en deel je de resterende ruimte gelijkmatig boven- en onder de cel.

#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);

De eerste splitsing voegt een rasterrij toe, waardoor de onderste 90 punten bij (1, 1) blijven. De tweede splitsing richt zich op die cel en voegt nog een rij eronder toe. De rechterkolom bevat nu (1, 0) van 50 punten (margin), (1, 1) van 40 punten en (1, 2) van 50 punten (margin). De linkercel beslaat alle drie de rijen met haar oorspronkelijke hoogte van 140 punten.

De linkercel beslaat de volledige tabelhoogte naast drie cellen met Midden in het midden.

De achtergrondkleur van de tabelcel wijzigen

Dit voorbeeld maakt een tabel met kolommen van 150 punten en rijen van 50 punten. Het gebruikt set_FillType om een egale vulling te selecteren en get_SolidFillColor om de vulkleur te benaderen en deze op rood te zetten voor cel (2, 3), in de derde kolom en vierde rij.

#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);

Een afbeelding in een tabelcel toevoegen

Plaats de invoerafbeelding in de werkmap voordat je dit voorbeeld uitvoert. Het laadt de afbeelding met Images::FromFile en voegt deze toe aan de afbeeldingscollectie van de presentatie met AddImage. Vervolgens kent het de afbeelding toe aan de afbeeldingsvulling van cel (0, 0), de eerste cel in de tabel.

PictureFillMode::Stretch strekt de afbeelding zodat deze de cel vult, wat de aspectverhouding kan wijzigen. Kolombreedtes en rijhoogtes zijn in punten. De geladen afbeelding wordt verwijderd nadat ze aan de presentatie is toegevoegd.

#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);

Veelgestelde vragen

Kan ik verschillende lijndiktes en stijlen instellen voor verschillende zijden van één cel?

Ja. De top/bottom/left/right randen hebben afzonderlijke eigenschappen, zodat de dikte en stijl van elke zijde kan verschillen.

Wat gebeurt er met de afbeelding als ik de kolom‑/rij‑grootte wijzig nadat ik een afbeelding als achtergrond van de cel heb ingesteld?

Het gedrag hangt af van de fill mode (stretch/tile). Bij stretchen past de afbeelding zich aan de nieuwe cel aan; bij tegelen worden de tegels opnieuw berekend.

Kan ik een hyperlink toewijzen aan alle inhoud van een cel?

Hyperlinks worden ingesteld op het tekst‑ (deel)niveau binnen het tekstframe van de cel of op het niveau van de volledige tabel/vorm. In de praktijk wijs je de link toe aan een deel of aan alle tekst in de cel.

Kan ik verschillende lettertypen instellen binnen één cel?

Ja. Het tekstframe van een cel ondersteunt portions (runs) met onafhankelijke opmaak — lettertypefamilie, stijl, grootte en kleur.