Spécifier Les Options De Chargement
Lors du chargement d’un document, vous pouvez définir certaines propriétés avancées. Aspose.Words vous fournit la classe LoadOptions, qui permet un contrôle plus précis du processus de chargement. Certains formats de chargement ont une classe correspondante qui contient des options de chargement pour ce format de chargement, par exemple, il y a PdfLoadOptions pour le chargement au format PDF ou TxtLoadOptions pour le chargement au format TXT. Cet article fournit des exemples d’utilisation des options de la classe LoadOptions.
Définir la version de Microsoft Word pour modifier l’apparence
Différentes versions de l’application Microsoft Word peuvent afficher des documents indifféremment. Par exemple, il existe un problème bien connu avec les documents OOXML tels que DOCX ou DOTX produits à l’aide de WPS Office. Dans ce cas, des éléments de balisage de document essentiels peuvent être manquants ou peuvent être interprétés différemment, ce qui fait que Microsoft Word 2019 affiche un tel document différemment de Microsoft Word 2010.
Par défaut, Aspose.Words ouvre les documents à l’aide des règles Microsoft Word 2019. Si vous devez faire apparaître le chargement du document comme cela se produirait dans l’une des versions précédentes de l’application Microsoft Word, vous devez spécifier explicitement la version souhaitée à l’aide de la propriété MswVersion de la classe LoadOptions.
L’exemple de code suivant montre comment définir la version de Microsoft Word avec des options de chargement:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>(); | |
// Change the loading version to Microsoft Word 2010. | |
loadOptions->set_MswVersion(MsWordVersion::Word2010); | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Document.docx", loadOptions); | |
System::String outputPath = outputDataDir + u"Load_Options.SetMSWordVersion.docx"; | |
doc->Save(outputPath); |
Définissez les préférences de langue pour modifier l’apparence
Les détails de l’affichage d’un document dans Microsoft Word dépendent non seulement de la version de l’application et de la valeur de la propriété MswVersion, mais également des paramètres de langue. Microsoft Word peut afficher les documents différemment selon les paramètres de la boîte de dialogue “Préférences de langue Office”, qui se trouvent dans “Fichier → Options → Langue”. En utilisant cette boîte de dialogue, un utilisateur peut sélectionner, par exemple, la langue principale, les langues d’épreuvage, les langues d’affichage,etc. Aspose.Words fournit la propriété LanguagePreferences comme l’équivalent de cette boîte de dialogue. Si la sortie Aspose.Words diffère de la sortie Microsoft Word, définissez la valeur appropriée pour EditingLanguage – cela peut améliorer le document de sortie.
L’exemple de code suivant montre comment définir le japonais sur EditingLanguage:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// Create a new LoadOptions object. | |
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>(); | |
// Set language preferences that will be used when document is loading. | |
loadOptions->get_LanguagePreferences()->AddEditingLanguage(EditingLanguage::Japanese); | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"languagepreferences.docx", loadOptions); |
Utilisez WarningCallback pour Contrôler les Problèmes Lors du Chargement d’un Document
Certains documents peuvent être corrompus, contenir des entrées invalides ou avoir des fonctionnalités non actuellement prises en charge par Aspose.Words. Si vous souhaitez connaître les problèmes survenus lors du chargement d’un document, Aspose.Words fournit l’interface IWarningCallback.
L’exemple de code suivant montre l’implémentation de l’interface IWarningCallback:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
class DocumentLoadingWarningCallback : public IWarningCallback | |
{ | |
public: | |
System::SharedPtr<WarningInfoCollection> mWarnings; | |
void Warning(System::SharedPtr<WarningInfo> info) override; | |
DocumentLoadingWarningCallback(); | |
}; | |
void DocumentLoadingWarningCallback::Warning(System::SharedPtr<WarningInfo> info) | |
{ | |
// Prints warnings and their details as they arise during document loading. | |
std::cout << "WARNING: {info->get_WarningType} " << std::endl; | |
std::cout << "Source: {info->get_Source} " << std::endl; | |
std::cout << "\tDescription: {info->get_Description} " << std::endl; | |
} | |
DocumentLoadingWarningCallback::DocumentLoadingWarningCallback() : mWarnings(System::MakeObject<WarningInfoCollection>()) | |
{ | |
} |
Pour obtenir des informations sur tous les problèmes tout au long du temps de chargement, utilisez la propriété WarningCallback
.
L’exemple de code suivant montre comment utiliser cette propriété:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// Create a new LoadOptions object and set its WarningCallback property. | |
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>(); | |
System::SharedPtr<DocumentLoadingWarningCallback> callback = System::MakeObject<DocumentLoadingWarningCallback>(); | |
loadOptions->set_WarningCallback(callback); | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Document.docx", loadOptions); |
Utilisez ResourceLoadingCallback pour contrôler le chargement des Ressources externes
Un document peut contenir des liens externes vers des images situées quelque part sur un disque local, un réseau ou Internet. Aspose.Words charge automatiquement ces images dans un document, mais il existe des situations où ce processus doit être contrôlé. Par exemple, pour décider si nous devons vraiment charger une certaine image ou peut-être l’ignorer. L’option de chargement ResourceLoadingCallback vous permet de contrôler cela.
L’exemple de code suivant montre l’implémentation de l’interface IResourceLoadingCallback:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
class HtmlLinkedResourceLoadingCallback : public IResourceLoadingCallback | |
{ | |
public: | |
ResourceLoadingAction ResourceLoading(System::SharedPtr<ResourceLoadingArgs> args) override; | |
HtmlLinkedResourceLoadingCallback(); | |
}; | |
HtmlLinkedResourceLoadingCallback::HtmlLinkedResourceLoadingCallback() | |
{ | |
} | |
ResourceLoadingAction HtmlLinkedResourceLoadingCallback::ResourceLoading(System::SharedPtr<ResourceLoadingArgs> args) | |
{ | |
switch (args->get_ResourceType()) | |
{ | |
case ResourceType::CssStyleSheet: | |
{ | |
std::cout << "External CSS Stylesheet found upon loading: " << args->get_OriginalUri().ToUtf8String() << std::endl; | |
// CSS file will don't used in the document | |
return ResourceLoadingAction::Skip; | |
} | |
case ResourceType::Image: | |
{ | |
// Replaces all images with a substitute | |
System::String newImageFilename = u"Logo.jpg"; | |
std::cout << "\tImage will be substituted with: " << newImageFilename.ToUtf8String() << std::endl; | |
System::SharedPtr<System::Drawing::Image> newImage = System::Drawing::Image::FromFile(GetInputDataDir_LoadingAndSaving() + newImageFilename); | |
System::SharedPtr<System::Drawing::ImageConverter> converter = System::MakeObject<System::Drawing::ImageConverter>(); | |
auto imageBytes = System::DynamicCast<System::Array<uint8_t>>(converter->ConvertTo(nullptr, nullptr, newImage, System::ObjectExt::GetType<System::Array<uint8_t>>())); | |
//System::ArrayPtr<uint8_t> imageBytes = System::IO::File::ReadAllBytes(GetInputDataDir_LoadingAndSaving() + newImageFilename); | |
args->SetData(imageBytes); | |
// New images will be used instead of presented in the document | |
return ResourceLoadingAction::UserProvided; | |
} | |
case ResourceType::Document: | |
{ | |
std::cout << "External document found upon loading: " << args->get_OriginalUri().ToUtf8String() << std::endl; | |
// Will be used as usual | |
return ResourceLoadingAction::Default; | |
} | |
default: | |
throw System::InvalidOperationException(u"Unexpected ResourceType value."); | |
} | |
} | |
L’exemple de code suivant montre comment utiliser la propriété ResourceLoadingCallback:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// Create a new LoadOptions object and set its ResourceLoadingCallback attribute as an instance of our IResourceLoadingCallback implementation | |
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>(); | |
loadOptions->set_ResourceLoadingCallback(System::MakeObject<HtmlLinkedResourceLoadingCallback>()); | |
// When we open an Html document, external resources such as references to CSS stylesheet files and external images | |
// will be handled in a custom manner by the loading callback as the document is loaded | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Images.html", loadOptions); | |
doc->Save(outputDataDir + u"Load_Options.LoadOptionsResourceLoadingCallback.pdf"); |
Utilisez TempFolder pour éviter une exception de mémoire
Aspose.Words prend en charge des documents extrêmement volumineux contenant des milliers de pages pleines de contenu riche. Le chargement de tels documents peut nécessiter beaucoup de RAM. En cours de chargement, Aspose.Words a besoin d’encore plus de mémoire pour contenir les structures temporaires utilisées pour analyser un document.
Si vous rencontrez un problème avec l’exception de mémoire insuffisante lors du chargement d’un document, essayez d’utiliser la propriété TempFolder. Dans ce cas, Aspose.Words stockera certaines données dans des fichiers temporaires au lieu de la mémoire, ce qui peut aider à éviter une telle exception.
L’exemple de code suivant montre comment définir TempFolder:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>(); | |
loadOptions->set_TempFolder(u"C:/TempFolder/"); | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Document.docx", loadOptions); |
Définir l’encodage Explicitement
La plupart des formats de documents modernes stockent leur contenu en Unicode et ne nécessitent aucune manipulation particulière. D’un autre côté, il existe encore de nombreux documents qui utilisent un codage pré-Unicode et parfois manquent des informations de codage ou ne prennent même pas en charge les informations de codage par nature. Aspose.Words essaie de détecter automatiquement l’encodage approprié par défaut, mais dans de rares cas, vous devrez peut-être utiliser un encodage différent de celui détecté par notre algorithme de reconnaissance d’encodage. Dans ce cas, utilisez la propriété Encoding pour obtenir ou définir l’encodage.
L’exemple de code suivant montre comment définir l’encodage pour remplacer l’encodage choisi automatiquement:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// Set the Encoding attribute in a LoadOptions object to override the automatically chosen encoding with the one we know to be correct | |
System::SharedPtr<LoadOptions> loadOptions = System::MakeObject<LoadOptions>(); | |
loadOptions->set_Encoding(System::Text::Encoding::get_UTF7()); | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(inputDataDir + u"Encoded in UTF-7.txt", loadOptions); |
Charger Des Documents Chiffrés
Vous pouvez charger des documents Word cryptés avec un mot de passe. Pour ce faire, utilisez une surcharge de constructeur spéciale, qui accepte un objet LoadOptions. Cet objet contient la propriété Password, qui spécifie la chaîne de mot de passe.
L’exemple de code suivant montre comment charger un document chiffré avec un mot de passe:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
// The path to the documents directory. | |
System::String dataDir = GetInputDataDir_LoadingAndSaving(); | |
// Loads encrypted document. | |
System::SharedPtr<Document> doc = System::MakeObject<Document>(dataDir + u"LoadEncrypted.docx", System::MakeObject<LoadOptions>(u"aspose")); | |
Si vous ne savez pas à l’avance si le fichier est crypté, vous pouvez utiliser la classe FileFormatUtil, qui fournit des méthodes utilitaires pour travailler avec les formats de fichiers, telles que la détection du format de fichier ou la conversion des extensions de fichier vers/depuis des énumérations de format de fichier. Pour détecter si le document est chiffré et nécessite un mot de passe pour l’ouvrir, utilisez la propriété IsEncrypted
.
L’exemple de code suivant montre comment vérifier OpenDocument s’il est chiffré ou non:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
System::SharedPtr<FileFormatInfo> info = FileFormatUtil::DetectFileFormat(inputDataDir + u"encrypted.odt"); | |
std::cout << info->get_IsEncrypted() << std::endl; |