Especificar Opções De Carregamento
Ao carregar um documento, pode definir algumas propriedades avançadas. Aspose.Words fornece a classe LoadOptions, que permite um controle mais preciso do processo de carga. Alguns formatos de carga têm uma classe correspondente que contém opções de carga para este formato de carga, por exemplo, existe PdfLoadOptions para carregar para o formato PDF ou TxtLoadOptions para carregar para TXT. Este artigo fornece exemplos de trabalho com opções da classe LoadOptions.
Definir Microsoft Word versão para alterar a aparência
Diferentes versões da aplicação Microsoft Word podem apresentar documentos indiferentemente. Por exemplo, existe um problema bem conhecido com OOXML documentos como DOCX ou DOTX produzidos utilizando WPS Office. Nesse caso, os elementos essenciais de marcação de documentos podem estar em falta ou podem ser interpretados de forma diferente, fazendo com que Microsoft Word 2019 mostre esse documento de forma diferente em comparação com Microsoft Word 2010.
Por padrão, Aspose.Words abre documentos usando as regras Microsoft Word 2019. Se você precisar fazer com que o carregamento de documentos apareça como aconteceria em uma das versões anteriores do aplicativo Microsoft Word, especifique explicitamente a versão desejada usando a propriedade MswVersion da classe LoadOptions.
O exemplo de código a seguir mostra como definir a versão Microsoft Word com opções de carregamento:
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); |
Definir preferências de idioma para alterar a aparência
Os detalhes da exibição de um documento em Microsoft Word dependem não apenas da versão do aplicativo e do valor da propriedade MswVersion, mas também das configurações de idioma. Microsoft Word pode apresentar documentos de forma diferente, dependendo das definições da caixa de diálogo “Preferências de idioma do Office”, que pode ser encontrada em “Ficheiro Opções de Ficheiro Opções de idioma”. Utilizando esta caixa de diálogo, o utilizador pode seleccionar, por exemplo, o idioma principal, os idiomas de revisão, os idiomas de apresentação, etc. Aspose.Words fornece a propriedade LanguagePreferences como equivalente a esta caixa de diálogo. Se a saída Aspose.Words for diferente da saída Microsoft Word, Defina o valor apropriado para EditingLanguage – isso pode melhorar o documento de saída.
O exemplo de código a seguir mostra como definir japonês como 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); |
Use WarningCallback para controlar problemas ao carregar um documento
Alguns documentos podem estar corrompidos, conter entradas inválidas ou ter funcionalidades actualmente não suportadas por Aspose.Words. Se você quiser saber sobre problemas que ocorreram durante o carregamento de um documento, Aspose.Words fornece a interface IWarningCallback.
O exemplo de código a seguir mostra a implementação da 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>()) | |
{ | |
} |
Para obter informações sobre todos os problemas ao longo do tempo de carregamento, use a propriedade WarningCallback
.
O exemplo de código a seguir mostra como usar essa propriedade:
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); |
Use ResourceLoadingCallback para controlar o carregamento de recursos externos
Um documento pode conter links externos para imagens localizadas em algum lugar em um disco local, rede ou Internet. Aspose.Words carrega automaticamente essas imagens em um documento, mas há situações em que esse processo precisa ser controlado. Por exemplo, para decidir se realmente precisamos carregar uma determinada imagem ou talvez ignorá-la. A opção de carregamento ResourceLoadingCallback permite-lhe controlar isto.
O exemplo de código a seguir mostra a implementação da 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."); | |
} | |
} | |
O exemplo de código a seguir mostra como usar a propriedade 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"); |
Use TempFolder para evitar uma exceção de memória
Aspose.Words suporta documentos extremamente grandes que têm milhares de páginas cheias de conteúdo rico. O carregamento desses documentos pode exigir muito RAM. No processo de carregamento, Aspose.Words precisa de ainda mais memória para armazenar estruturas temporárias usadas para analisar um documento.
Se você tiver um problema com a exceção falta de memória ao carregar um documento, tente usar a propriedade TempFolder. Nesse caso, Aspose.Words armazenará alguns dados em arquivos temporários em vez de memória, e isso pode ajudar a evitar essa exceção.
O exemplo de código a seguir mostra como definir 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); |
Definir a codificação explicitamente
A maioria dos formatos de documentos modernos armazena seu conteúdo em Unicode e não requer tratamento especial. Por outro lado, ainda existem muitos documentos que utilizam alguma codificação pré-Unicode e, por vezes, perdem informações de codificação ou nem sequer suportam informações de codificação por natureza. Aspose.Words tenta detectar automaticamente a codificação apropriada por padrão, mas em um caso raro você pode precisar usar uma codificação diferente da detectada pelo nosso algoritmo de reconhecimento de codificação. Nesse caso, use a propriedade Encoding para obter ou definir a codificação.
O exemplo de código a seguir mostra como definir a codificação para substituir a codificação escolhida automaticamente:
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); |
Carregar Documentos Encriptados
Você pode carregar documentos do Word criptografados com uma senha. Para fazer isso, use uma sobrecarga de construtor especial, que aceita um objeto LoadOptions. Este objecto contém a propriedade Password, que especifica a cadeia de palavras-passe.
O exemplo de código a seguir mostra como carregar um documento criptografado com uma senha:
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")); | |
Se você não souber com antecedência se o arquivo está criptografado, poderá usar a classe FileFormatUtil, que fornece métodos utilitários para trabalhar com formatos de arquivo, como detectar o formato do arquivo ou converter extensões de arquivo de/para enumerações de formato de arquivo. Para detectar se o documento está criptografado e requer uma senha para abri-lo, use a propriedade IsEncrypted
.
O exemplo de código a seguir mostra como verificar OpenDocument se ele está criptografado ou não:
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; |