Gestion des classeurs de graphiques dans les présentations avec C++
Vue d’ensemble
Cet article explique comment travailler avec les classeurs de graphiques dans Aspose.Slides. Il montre comment lire et écrire des données de graphique via des flux de classeur, utiliser les cellules du classeur comme libellés de données de graphique, accéder aux collections de feuilles de calcul et spécifier le type de source de données pour les valeurs du graphique.
Il couvre également l’utilisation de classeurs externes comme sources de données de graphique. Les exemples montrent comment créer et affecter un classeur externe, récupérer le chemin d’un classeur externe lié à un graphique et modifier les données du graphique lorsque le classeur est disponible.
Pour les cellules de classeur qui représentent des données manquantes, voir Contrôler l’affichage des cellules vides pour la différence entre une cellule vide et zéro, ainsi qu’une comparaison en graphique en courbes des modes d’affichage disponibles.
Inclure des données provenant de lignes et colonnes cachées
Utilisez IChart::set_PlotVisibleCellsOnly pour contrôler si un graphique trace les données provenant de lignes et colonnes de feuille masquées. Définissez-le sur true pour tracer uniquement les cellules visibles, ou sur false pour inclure à la fois les cellules visibles et masquées. Ce réglage contrôle le traçage du graphique ; il ne masque ni n’affiche les lignes ou colonnes de la feuille de calcul.
La présentation d’exemple contient un graphique à colonnes comme première forme de la première diapositive. La feuille de calcul intégrée, Sheet1, contient la plage source suivante, A1:C4. La ligne 3 et la colonne C sont masquées, mais leurs cellules contiennent toujours des valeurs.
| Ligne de feuille | A : Mois | B : Vente au détail | C : Vente en gros (colonne masquée) |
|---|---|---|---|
| 2 | Janvier | 10 | 30 |
| 3 (ligne masquée) | Février | 40 | 60 |
| 4 | Mars | 20 | 50 |
Accédez aux cellules sources via IChartData::get_ChartDataWorkbook et lisez IChartDataCell::get_IsHidden pour inspecter leur statut masqué. Cette propriété est en lecture seule. Dans ce fichier, B2 est visible, B3 appartient à la ligne masquée et C2 appartient à la colonne masquée ; l’exemple affiche False, True et True, respectivement.
Pour cet exemple, rafraîchissez les données du graphique après avoir modifié le réglage de traçage : conservez le classeur intégré avec ReadWorkbookStream et rechargez-le avec WriteWorkbookStream. Lors de l’inclusion de toutes les cellules, utilisez également SetRange pour restaurer la plage complète, y compris la catégorie de février masquée. Modifier simplement le drapeau n’est pas suffisant pour rafraîchir les données en cache de cet exemple ainsi que les libellés de catégorie.
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <initializer_list>
#include <system/console.h>
#include <system/io/memory_stream.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>(u"hidden-source-data.pptx");
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->get_Count() > 0 ? AsCast<IChart>(slide->get_Shape(0)) : nullptr;
if (chart != nullptr)
{
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
Console::WriteLine(u"B2 hidden: {0}", workbook->GetCell(0, u"B2")->get_IsHidden());
Console::WriteLine(u"B3 hidden: {0}", workbook->GetCell(0, u"B3")->get_IsHidden());
Console::WriteLine(u"C2 hidden: {0}", workbook->GetCell(0, u"C2")->get_IsHidden());
auto workbookStream = chart->get_ChartData()->ReadWorkbookStream();
for (auto visibleOnly : {true, false})
{
chart->set_PlotVisibleCellsOnly(visibleOnly);
// Rafraîchir les données du graphique depuis le classeur intégré.
workbookStream->set_Position(0);
chart->get_ChartData()->WriteWorkbookStream(workbookStream);
if (!visibleOnly)
{
// Restaurer la plage source complète, y compris les catégories masquées.
chart->get_ChartData()->SetRange(u"Sheet1!$A$1:$C$4");
}
auto outputPath = visibleOnly ? u"hidden_cells_True.pptx" : u"hidden_cells_False.pptx";
presentation->Save(outputPath, Export::SaveFormat::Pptx);
}
}
else
{
Console::WriteLine(u"The first shape is not a chart.");
}
L’exemple enregistre deux versions de la présentation : une avec uniquement les valeurs visibles de vente au détail (10 et 20) et une autre avec les six valeurs. Les images ci‑dessous illustrent les deux modes de traçage. La ligne 3 et la colonne C restent masquées dans les deux classeurs intégrés.
Cellules visibles uniquement (true) |
Toutes les cellules (false) |
|---|---|
 |
 |
Une cellule masquée contenant une valeur est différente d’une cellule vide. IChart::get_DisplayBlanksAs contrôle la façon dont les valeurs manquantes sont affichées ; il n’inclut ni n’exclut les données sources masquées. Voir Contrôler l’affichage des cellules vides pour un exemple.
Récupérer la plage de données d’un graphique
Avant de mettre à jour les données du classeur dans une présentation existante, inspectez les plages sources afin d’identifier quelles cellules de feuille chaque graphique utilise. La méthode IChartData::GetRange renvoie la plage de données actuelle sous forme de formule qualifiée par la feuille, telle que Sheet1!$A$1:$D$5. Ici, Sheet1 est le nom de la feuille, ! la sépare de la plage de cellules, et $A$1:$D$5 identifie les cellules A1 à D5 incluses. Le symbole $ indique des références de ligne et de colonne absolues.
La méthode lit la plage actuelle sans modifier le graphique ni son classeur. Si le graphique n’utilise pas de classeur comme source de données, elle lève System::InvalidOperationException. Pour plus d’informations, consultez la Référence API ChartData.
Cet exemple ouvre une présentation et parcourt les formes de chaque diapositive à la recherche de graphiques. Il affiche le nom de chaque graphique et sa plage source. Si un graphique n’utilise pas de classeur, il affiche un message et passe au graphique suivant.
#include <DOM/Chart/IChartData.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/Presentation.h>
#include <system/console.h>
#include <system/enumerator_adapter.h>
#include <system/exceptions.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>(u"presentation.pptx");
for (auto slide : IterateOver(presentation->get_Slides()))
{
for (auto shape : IterateOver(slide->get_Shapes()))
{
auto chart = AsCast<IChart>(shape);
if (chart != nullptr)
{
try
{
auto range = chart->get_ChartData()->GetRange();
Console::WriteLine(u"{0}: {1}", chart->get_Name(), range);
}
catch (const InvalidOperationException&)
{
Console::WriteLine(u"{0}: The chart does not use a workbook as its data source.", chart->get_Name());
}
}
}
}
Lire et écrire des données de graphique depuis un classeur
Aspose.Slides pour C++ fournit les méthodes ReadWorkbookStream et WriteWorkbookStream qui permettent de lire et d’écrire les classeurs de données de graphique (contenant des données de graphique modifiées avec Aspose.Cells). Note que les données du graphique doivent être organisées de la même manière ou posséder une structure similaire à la source.
Cet exemple utilise une présentation contenant un graphique comme première forme de la première diapositive. Il lit le classeur intégré dans un flux, supprime les séries et catégories existantes, puis réécrit le même classeur. Les changements restent en mémoire ; l’exemple ne sauvegarde pas la présentation.
#include <DOM/Chart/IChartCategoryCollection.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <system/console.h>
#include <system/io/memory_stream.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>(u"chart.pptx");
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->get_Count() > 0 ? AsCast<IChart>(slide->get_Shape(0)) : nullptr;
if (chart != nullptr)
{
auto chartData = chart->get_ChartData();
auto workbookStream = chartData->ReadWorkbookStream();
chartData->get_Series()->Clear();
chartData->get_Categories()->Clear();
workbookStream->set_Position(0);
chartData->WriteWorkbookStream(workbookStream);
}
else
{
Console::WriteLine(u"The first shape is not a chart.");
}
Valider la mise en page du graphique après modification du classeur
Lorsque vous remplacez un classeur intégré par un classeur modifié, le graphique conserve ses collections de séries et de catégories d’origine. Cette incohérence peut entraîner l’échec de IChart::ValidateChartLayout avec une erreur d’indice hors plage. Supprimez les séries et catégories existantes avant d’écrire le classeur mis à jour dans le graphique. Cet exemple utilise un graphique qui est la première forme de la première diapositive. Le commentaire indique où l’édition du classeur aurait lieu ; l’exemple exécutable réécrit le classeur d’origine et valide la mise en page en mémoire.
#include <DOM/Chart/IChartCategoryCollection.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <system/console.h>
#include <system/io/memory_stream.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>(u"chart.pptx");
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->get_Count() > 0 ? AsCast<IChart>(slide->get_Shape(0)) : nullptr;
if (chart != nullptr)
{
auto chartData = chart->get_ChartData();
auto workbookStream = chartData->ReadWorkbookStream();
// Modifier le flux du classeur ici, par exemple en utilisant Aspose.Cells.
chartData->get_Series()->Clear();
chartData->get_Categories()->Clear();
workbookStream->set_Position(0);
chartData->WriteWorkbookStream(workbookStream);
chart->ValidateChartLayout();
}
else
{
Console::WriteLine(u"The first shape is not a chart.");
}
Supprimer les collections élimine les références de données obsolètes avant que le classeur ne soit réécrit. Reconstruisez les mappages de séries et de catégories nécessaires pour le classeur mis à jour avant d’utiliser le graphique.
Définir des formats numériques personnalisés pour les cellules du classeur
Utilisez IChartDataCell::set_CustomNumberFormat pour contrôler l’apparence des valeurs numériques dans le classeur intégré du graphique. Par exemple, un rapport peut nécessiter d’afficher un taux de conversion en pourcentage avec quatre décimales et un coefficient avec cinq décimales. Conservez les deux valeurs au format numérique afin qu’elles restent disponibles pour les calculs et le traçage du graphique.
Un format numérique change l’affichage, pas la valeur stockée. Le format 0.0000% affiche 0.125 comme 12.5000% ; il ne remplace pas le nombre stocké par 12.5. De même, 0.00000 affiche 0.1234567 comme 0.12346 sans arrondir la valeur stockée. Si le format personnalisé est une chaîne vide (""), le format assigné via set_PresetNumberFormat est utilisé à la place.
L’exemple suivant crée un graphique à colonnes et accède à ses cellules via IChartData::get_ChartDataWorkbook. Sur la feuille 0, B2 contient le taux de conversion et C2 le coefficient. Les deux cellules fournissent les valeurs du graphique. L’exemple active également les libellés de valeur liés aux formats sources.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IAxesManager.h>
#include <DOM/Chart/IAxis.h>
#include <DOM/Chart/IChartCategoryCollection.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataPoint.h>
#include <DOM/Chart/IChartDataPointCollection.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IDataLabel.h>
#include <DOM/Chart/IDataLabelFormat.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideSize.h>
#include <DOM/Presentation.h>
#include <DOM/SlideSizeScaleType.h>
#include <Export/SaveFormat.h>
#include <system/enumerator_adapter.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
presentation->get_SlideSize()->SetSize(720, 270, SlideSizeScaleType::DoNotScale);
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 50, 20, 620, 210);
chart->set_HasTitle(false);
chart->get_Axes()->get_VerticalAxis()->set_IsNumberFormatLinkedToSource(false);
chart->get_Axes()->get_VerticalAxis()->set_NumberFormat(u"0.00");
chart->get_Axes()->get_VerticalAxis()->set_IsAutomaticMinValue(false);
chart->get_Axes()->get_VerticalAxis()->set_MinValue(0);
chart->get_ChartData()->get_Series()->Clear();
chart->get_ChartData()->get_Categories()->Clear();
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
workbook->Clear(0);
auto categoryCell = workbook->GetCell(0, u"A2", ObjectExt::Box<String>(u"Sample"));
chart->get_ChartData()->get_Categories()->Add(categoryCell);
auto percentageCell = workbook->GetCell(0, u"B2", ObjectExt::Box<double>(0.125));
percentageCell->set_CustomNumberFormat(u"0.0000%");
auto percentageName = workbook->GetCell(0, u"B1", ObjectExt::Box<String>(u"Conversion rate"));
auto percentageSeries = chart->get_ChartData()->get_Series()->Add(percentageName, chart->get_Type());
percentageSeries->get_DataPoints()->AddDataPointForBarSeries(percentageCell);
auto precisionCell = workbook->GetCell(0, u"C2", ObjectExt::Box<double>(0.1234567));
precisionCell->set_CustomNumberFormat(u"0.00000");
auto precisionName = workbook->GetCell(0, u"C1", ObjectExt::Box<String>(u"Coefficient"));
auto precisionSeries = chart->get_ChartData()->get_Series()->Add(precisionName, chart->get_Type());
precisionSeries->get_DataPoints()->AddDataPointForBarSeries(precisionCell);
for (auto series : IterateOver(chart->get_ChartData()->get_Series()))
{
auto labelFormat = series->get_DataPoint(0)->get_Label()->get_DataLabelFormat();
labelFormat->set_ShowValue(true);
labelFormat->set_IsNumberFormatLinkedToSource(true);
}
presentation->Save(u"CustomCellFormats.pptx", Export::SaveFormat::Pptx);
Les formats de cellules du classeur sont séparés des formats définis directement sur les axes du graphique ou les libellés de données. Dans cet exemple, chaque libellé affiche la valeur de sa cellule source parce que set_ShowValue est appelé avec true, et suit le format numérique source parce que set_IsNumberFormatLinkedToSource est appelé avec true. Après avoir enregistré et rouvert la présentation, les libellés affichent 12.5000% et 0.12346, comme indiqué ci‑dessous. L’axe vertical utilise son propre format 0.00, assigné via set_NumberFormat, avec set_IsNumberFormatLinkedToSource appelé avec false.
Pour formater un libellé de données indépendamment, désactivez le drapeau de lien source (false) et assignez son format via set_NumberFormat. Cela ne modifie pas le format de la cellule du classeur. Par exemple, un format de libellé indépendant 0.00 affiche la première valeur comme 0.13, tandis que B2 continue d’afficher 12.5000%. Consultez Chart Data Labels pour le formatage direct des libellés.
L’image ci‑dessous a été rendue à partir de la présentation enregistrée après l’avoir réouverte :
Utiliser une cellule de classeur comme libellé de données du graphique
Vous pouvez utiliser le texte des cellules de classeur comme libellés de données du graphique.
Cet exemple ajoute un graphique à bulles avec des données par défaut à la première diapositive d’une présentation existante. Il utilise les cellules A10 : A12 de la feuille 0 pour les trois premiers libellés de la première série, active les libellés provenant des cellules et enregistre la présentation mise à jour.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IDataLabel.h>
#include <DOM/Chart/IDataLabelCollection.h>
#include <DOM/Chart/IDataLabelFormat.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>(u"chart2.pptx");
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::Bubble, 50, 50, 600, 400, true);
auto series = chart->get_ChartData()->get_Series()->idx_get(0);
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
series->get_Labels()->get_DefaultDataLabelFormat()->set_ShowLabelValueFromCell(true);
auto firstLabelCell = workbook->GetCell(0, u"A10", ObjectExt::Box<String>(u"Label 0 cell value"));
auto secondLabelCell = workbook->GetCell(0, u"A11", ObjectExt::Box<String>(u"Label 1 cell value"));
auto thirdLabelCell = workbook->GetCell(0, u"A12", ObjectExt::Box<String>(u"Label 2 cell value"));
series->get_Labels()->idx_get(0)->set_ValueFromCell(firstLabelCell);
series->get_Labels()->idx_get(1)->set_ValueFromCell(secondLabelCell);
series->get_Labels()->idx_get(2)->set_ValueFromCell(thirdLabelCell);
presentation->Save(u"resultchart.pptx", Export::SaveFormat::Pptx);
Gestion des feuilles de calcul
La méthode IChartDataWorkbook::get_Worksheets fournit l’accès aux feuilles de calcul d’un classeur de graphique. Cet exemple crée un graphique circulaire avec des données par défaut et affiche le nom de chaque feuille de calcul dans la console.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartDataWorksheet.h>
#include <DOM/Chart/IChartDataWorksheetCollection.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <system/console.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::Pie, 50, 50, 400, 500);
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
for (auto i = 0; i < workbook->get_Worksheets()->get_Count(); i++)
{
Console::WriteLine(workbook->get_Worksheets()->idx_get(i)->get_Name());
}
Spécifier le type de source de données
Les valeurs des points de série peuvent également être stockées directement sous forme de littéraux numériques. Voir Set Series Values Using Numeric Literals pour un exemple complet qui les enregistre et les lit. Le type de source des valeurs de points est distinct de la configuration interne ou externe du classeur du graphique ; l’utilisation de littéraux numériques ne supprime pas, à elle seule, le classeur intégré.
Cet exemple crée un graphique à colonnes 3D avec des données par défaut et définit deux noms de séries à l’aide de sources de données différentes. Le premier nom utilise un littéral de chaîne ; le second utilise la cellule C1 de la feuille 0. L’énumération DataSourceType sélectionne la source pour chaque nom. L’exemple enregistre la présentation avec les noms de séries mis à jour.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/DataSourceType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IStringChartValue.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::Column3D, 50, 50, 600, 400, true);
auto literalName = chart->get_ChartData()->get_Series()->idx_get(0)->get_Name();
literalName->set_DataSourceType(DataSourceType::StringLiterals);
literalName->set_Data(ObjectExt::Box<String>(u"LiteralString"));
auto cellName = chart->get_ChartData()->get_Series()->idx_get(1)->get_Name();
auto nameCell = chart->get_ChartData()->get_ChartDataWorkbook()->GetCell(0, u"C1", ObjectExt::Box<String>(u"NewCell"));
cellName->set_DataSourceType(DataSourceType::Worksheet);
cellName->set_Data(nameCell);
presentation->Save(u"pres.pptx", Export::SaveFormat::Pptx);
Détecter les formats de classeur intégré non pris en charge
Aspose.Slides ne prend pas en charge le format de classeur Excel binaire (.xlsb) qui peut être intégré dans certains graphiques. Vous pouvez utiliser la méthode get_EmbeddedWorkbookType sur IChartData avec l’énumération WorkbookType pour détecter les formats non pris en charge et ignorer ces graphiques. Cet exemple inspecte les formes de la première diapositive d’une présentation existante, ignore les formes non graphiques et affiche un message diagnostique pour chaque graphique contenant un classeur .xlsb intégré.
#include <DOM/Chart/ChartDataSourceType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/WorkbookType.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <system/console.h>
#include <system/enumerator_adapter.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>(u"sample.pptx");
auto slide = presentation->get_Slide(0);
for (auto shape : IterateOver(slide->get_Shapes()))
{
auto chart = AsCast<IChart>(shape);
if (chart == nullptr)
{
continue;
}
auto chartData = chart->get_ChartData();
auto isInternalWorkbook = chartData->get_DataSourceType() == ChartDataSourceType::InternalWorkbook;
auto isBinaryMacro = chartData->get_EmbeddedWorkbookType() == WorkbookType::WorkbookBinaryMacro;
if (isInternalWorkbook && isBinaryMacro)
{
Console::WriteLine(u"Skipping a chart with an unsupported .xlsb workbook.");
continue;
}
// Lire ou modifier les données de classeur de graphique prises en charge ici.
}
Classeur externe
Aspose.Slides prend en charge l’utilisation de classeurs externes comme source de données pour les graphiques.
Créer un classeur externe
Utilisez ReadWorkbookStream et SetExternalWorkbook pour exporter le classeur de graphique intégré vers un fichier et lier le graphique à ce classeur externe.
Cet exemple crée un graphique circulaire avec des données par défaut et exporte son classeur. Il ferme le flux de sortie avant d’affecter le classeur externe comme source de données du graphique, puis enregistre la présentation liée.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/io/memory_stream.h>
#include <system/io/path.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::Pie, 50, 50, 400, 600);
auto workbookPath = IO::Path::GetFullPath(u"externalWorkbook1.xlsx");
auto workbookStream = chart->get_ChartData()->ReadWorkbookStream();
auto fileStream = IO::File::Create(workbookPath);
workbookStream->CopyTo(fileStream);
fileStream->Close();
chart->get_ChartData()->SetExternalWorkbook(workbookPath);
presentation->Save(u"externalWorkbook.pptx", Export::SaveFormat::Pptx);
Affecter un classeur externe
En utilisant la méthode SetExternalWorkbook, vous pouvez affecter un classeur externe à un graphique comme source de données. Cette méthode peut également être utilisée pour mettre à jour le chemin vers le classeur externe (si ce dernier a été déplacé).
Bien que vous ne puissiez pas modifier les données des classeurs stockés sur des emplacements distants ou des ressources, vous pouvez toujours les utiliser comme source de données externe. Si un chemin relatif pour un classeur externe est fourni, il est automatiquement converti en chemin complet.
Cet exemple utilise un classeur externe dont la feuille nommée Sheet1 contient un nom de série en B1, des noms de catégorie en A2 : A4 et des valeurs numériques en B2 : B4. L’exemple crée un graphique circulaire, lie le classeur et utilise SetRange pour mapper A1 : B4 à une série et trois catégories. Il enregistre la présentation avec le graphique lié.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/io/path.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::Pie, 50, 50, 400, 600, true);
auto chartData = chart->get_ChartData();
auto workbookPath = IO::Path::GetFullPath(u"externalWorkbook.xlsx");
chartData->SetExternalWorkbook(workbookPath);
chartData->SetRange(u"Sheet1!$A$1:$B$4");
presentation->Save(u"Presentation_with_externalWorkbook.pptx", Export::SaveFormat::Pptx);
Le paramètre updateChartData de SetExternalWorkbook contrôle le chargement du classeur.
- Lorsque
updateChartDataestfalse, seul le chemin du classeur est mis à jour. Les données du graphique ne sont pas chargées ou mises à jour depuis le classeur cible, de sorte que le classeur peut être indisponible. - Lorsque
updateChartDataesttrue, les données du graphique sont mises à jour depuis le classeur cible.
L’exemple suivant affecte une URL factice avec updateChartData défini sur false. Il conserve les données par défaut du graphique circulaire et enregistre la présentation sans charger le classeur indisponible.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::Pie, 50, 50, 400, 600, true);
chart->get_ChartData()->SetExternalWorkbook(u"https://example.com/unavailable-workbook.xlsx", false);
presentation->Save(u"SetExternalWorkbookWithUpdateChartData.pptx", Export::SaveFormat::Pptx);
Obtenir le chemin du classeur source de données externe d’un graphique
Pour identifier le classeur lié à un graphique, vérifiez si le graphique utilise une source de données externe et récupérez son chemin de classeur.
Cet exemple examine la première forme de la première diapositive d’une présentation contenant un classeur externe lié. Si c’est un graphique lié à un classeur externe, l’exemple affiche get_ExternalWorkbookPath dans la console. Il enregistre ensuite une copie de la présentation.
#include <DOM/Chart/ChartDataSourceType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>(u"externalWorkbook.pptx");
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->get_Count() > 0 ? AsCast<IChart>(slide->get_Shape(0)) : nullptr;
if (chart != nullptr)
{
auto chartData = chart->get_ChartData();
if (chartData->get_DataSourceType() == ChartDataSourceType::ExternalWorkbook)
{
Console::WriteLine(chartData->get_ExternalWorkbookPath());
}
else
{
Console::WriteLine(u"The chart does not use an external workbook.");
}
}
else
{
Console::WriteLine(u"The first shape is not a chart.");
}
presentation->Save(u"Result.pptx", Export::SaveFormat::Pptx);
Modifier les données du graphique
Vous pouvez modifier les données des classeurs externes de la même manière que vous modifiez le contenu des classeurs internes. Lorsqu’un classeur externe ne peut pas être chargé, une exception est levée.
Cet exemple utilise un graphique qui est la première forme de la première diapositive et qui est lié à un classeur externe accessible. Il affecte la valeur soutenue par la cellule du premier point de données de la première série à 100 et enregistre la présentation mise à jour. Modifier les valeurs des cellules peut mettre à jour le fichier XLSX externe lié, donc utilisez une copie si vous devez préserver le classeur original.
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataPoint.h>
#include <DOM/Chart/IChartDataPointCollection.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IDoubleChartValue.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>(u"presentation.pptx");
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->get_Count() > 0 ? AsCast<IChart>(slide->get_Shape(0)) : nullptr;
if (chart != nullptr)
{
auto series = chart->get_ChartData()->get_Series();
if (series->get_Count() > 0 && series->idx_get(0)->get_DataPoints()->get_Count() > 0)
{
auto valueCell = series->idx_get(0)->get_DataPoints()->idx_get(0)->get_Value()->get_AsCell();
if (valueCell != nullptr)
{
valueCell->set_Value(ObjectExt::Box<int32_t>(100));
presentation->Save(u"presentation_out.pptx", Export::SaveFormat::Pptx);
}
else
{
Console::WriteLine(u"The first data point is not linked to a workbook cell.");
}
}
else
{
Console::WriteLine(u"The chart has no data points to edit.");
}
}
else
{
Console::WriteLine(u"The first shape is not a chart.");
}
Récupérer un classeur depuis le cache du graphique
Si un graphique utilise un classeur externe manquant ou indisponible, Aspose.Slides peut reconstruire le classeur du graphique à partir des données mises en cache dans la présentation. Créez LoadOptions, configurez‑le avec set_SpreadsheetOptions, et appelez ISpreadsheetOptions::set_RecoverWorkbookFromChartCache avec true avant d’ouvrir la présentation.
L’exemple C++ suivant récupère les données du classeur pour un graphique qui est la première forme de la première diapositive et qui référence un classeur externe indisponible. Il accède aux données récupérées via IChart::get_ChartData et IChartData::get_ChartDataWorkbook :
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/LoadOptions.h>
#include <DOM/Presentation.h>
#include <DOM/SpreadsheetOptions.h>
#include <system/console.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto spreadsheetOptions = MakeObject<SpreadsheetOptions>();
spreadsheetOptions->set_RecoverWorkbookFromChartCache(true);
auto loadOptions = MakeObject<LoadOptions>();
loadOptions->set_SpreadsheetOptions(spreadsheetOptions);
auto presentation = MakeObject<Presentation>(u"presentation.pptx", loadOptions);
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->get_Count() > 0 ? AsCast<IChart>(slide->get_Shape(0)) : nullptr;
if (chart != nullptr)
{
auto recoveredWorkbook = chart->get_ChartData()->get_ChartDataWorkbook();
// Lire ou modifier les données du classeur récupéré ici.
}
else
{
Console::WriteLine(u"The first shape is not a chart.");
}
Si le classeur externe est indisponible et que la récupération est désactivée, Aspose.Slides lève une System::InvalidOperationException. activez la récupération uniquement lorsque l’utilisation des données du graphique en cache est une solution de repli acceptable, car le cache peut ne pas contenir les modifications apportées au classeur externe après la dernière mise à jour de la présentation.
FAQ
Puis-je déterminer si un graphique spécifique est lié à un classeur externe ou intégré ?
Oui. Un graphique possède un type de source de données et un chemin vers un classeur externe. Si la source est un classeur externe, vous pouvez lire le chemin complet pour vous assurer qu’un fichier externe est utilisé.
Les chemins relatifs vers les classeurs externes sont‑ils pris en charge, et comment sont‑ils stockés ?
Oui. Si vous spécifiez un chemin relatif, il est automatiquement converti en chemin absolu. La présentation stocke le chemin absolu dans le fichier PPTX, de sorte que le déplacement du classeur peut nécessiter la mise à jour du lien.
Puis‑je utiliser des classeurs situés sur des ressources ou partages réseau ?
Oui, ces classeurs peuvent être utilisés comme source de données externe. Cependant, la modification directe de classeurs distants depuis Aspose.Slides n’est pas prise en charge ; ils ne peuvent être utilisés que comme source.
Aspose.Slides écrase‑t‑il le fichier XLSX externe lors de l’enregistrement de la présentation ?
La présentation stocke un lien vers le fichier externe. Modifier les données du graphique soutenues par des cellules peut également mettre à jour le fichier XLSX local lié. Utilisez une copie du classeur si l’original doit rester inchangé.
Que faire si le fichier externe est protégé par un mot de passe ?
Aspose.Slides n’accepte pas de mot de passe lors de la création du lien. Une approche courante consiste à retirer la protection au préalable ou à préparer une copie décryptée (par exemple en utilisant Aspose.Cells) et à créer le lien vers cette copie.
Plusieurs graphiques peuvent‑ils référencer le même classeur externe ?
Oui. Chaque graphique stocke son propre lien. S’ils pointent tous vers le même fichier, la mise à jour de ce fichier sera reflétée dans chaque graphique lors du prochain chargement des données.