Insérer et ajouter des documents
Parfois, il est nécessaire de combiner plusieurs documents en un seul. Vous pouvez le faire manuellement ou vous pouvez utiliser la fonction d’insertion ou d’ajout Aspose.Words.
L’opération d’insertion vous permet d’insérer le contenu de documents créés précédemment dans un document nouveau ou existant.
À son tour, la fonction d’ajout vous permet d’ajouter un document uniquement à la fin d’un autre document.
Cet article explique comment insérer ou ajouter un document à un autre de différentes manières et décrit les propriétés courantes que vous pouvez appliquer lors de l’insertion ou de l’ajout de documents.
Insérer un document
Comme mentionné ci-dessus, dans Aspose.Words, un document est représenté comme un arbre de nœuds, et l’opération d’insertion d’un document dans un autre consiste à copier des nœuds du premier arbre de documents vers le second.
Vous pouvez insérer des documents à divers endroits de différentes manières. Par exemple, vous pouvez insérer un document via une opération de remplacement, un champ de fusion lors d’une opération de fusion ou via un signet.
Vous pouvez également utiliser la méthode InsertDocument, qui est similaire à l’insertion d’un document dans Microsoft Word, pour insérer un document entier à la position actuelle du curseur sans importation préalable.
L’exemple de code suivant montre comment insérer un document à l’aide de la méthode InsertDocument
:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
auto srcDoc = MakeObject<Document>(MyDir + u"Document source.docx"); | |
auto dstDoc = MakeObject<Document>(MyDir + u"Northwind traders.docx"); | |
auto builder = MakeObject<DocumentBuilder>(dstDoc); | |
builder->MoveToDocumentEnd(); | |
builder->InsertBreak(BreakType::PageBreak); | |
builder->InsertDocument(srcDoc, ImportFormatMode::KeepSourceFormatting); | |
builder->get_Document()->Save(ArtifactsDir + u"JoinAndAppendDocuments.InsertDocument.docx"); |
Les sous-sections suivantes décrivent les options au cours desquelles vous pouvez insérer un document dans un autre.
Insérer un Document Lors de l’Opération de Recherche et de remplacement
Vous pouvez insérer des documents tout en effectuant des opérations de recherche et de remplacement. Par exemple, un document peut contenir des paragraphes avec le texte [INTRODUCTION] et [CONCLUSION]. Mais dans le document final, vous devez remplacer ces paragraphes par le contenu obtenu à partir d’un autre document externe. Pour y parvenir, vous devrez créer un gestionnaire pour l’événement replace.
L’exemple de code suivant montre comment créer un gestionnaire pour l’événement de remplacement afin de l’utiliser ultérieurement dans le processus d’insertion:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
class InsertDocumentAtReplaceHandler : public IReplacingCallback | |
{ | |
private: | |
ReplaceAction Replacing(SharedPtr<ReplacingArgs> args) override | |
{ | |
auto subDoc = MakeObject<Document>(MyDir + u"Document insertion 2.docx"); | |
// Insert a document after the paragraph, containing the match text. | |
auto para = System::ExplicitCast<Paragraph>(args->get_MatchNode()->get_ParentNode()); | |
InsertDocument(para, subDoc); | |
// Remove the paragraph with the match text. | |
para->Remove(); | |
return ReplaceAction::Skip; | |
} | |
}; |
L’exemple de code suivant montre comment insérer le contenu d’un document dans un autre lors d’une opération de recherche et de remplacement:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
auto mainDoc = MakeObject<Document>(MyDir + u"Document insertion 1.docx"); | |
// Set find and replace options. | |
auto options = MakeObject<FindReplaceOptions>(); | |
options->set_Direction(FindReplaceDirection::Backward); | |
options->set_ReplacingCallback(MakeObject<CloneAndCombineDocuments::InsertDocumentAtReplaceHandler>()); | |
// Call the replace method. | |
mainDoc->get_Range()->Replace(MakeObject<System::Text::RegularExpressions::Regex>(u"\\[MY_DOCUMENT\\]"), u"", options); | |
mainDoc->Save(ArtifactsDir + u"CloneAndCombineDocuments.InsertDocumentAtReplace.docx"); |
Insérer un Document Pendant l’opération Mail Merge
Vous pouvez insérer un document dans un champ de fusion lors d’une opération mail merge. Par exemple, un modèle Mail Merge peut contenir un champ de fusion tel que [Résumé]. Mais dans le document final, vous devez insérer le contenu obtenu à partir d’un autre document externe dans ce champ de fusion. Pour y parvenir, vous devrez créer un gestionnaire pour l’événement de fusion.
L’exemple de code suivant montre comment créer un gestionnaire pour l’événement de fusion afin de l’utiliser ultérieurement dans le processus d’insertion:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
class InsertDocumentAtMailMergeHandler : public IFieldMergingCallback | |
{ | |
private: | |
void FieldMerging(SharedPtr<FieldMergingArgs> args) override | |
{ | |
if (args->get_DocumentFieldName() == u"Document_1") | |
{ | |
// Use document builder to navigate to the merge field with the specified name. | |
auto builder = MakeObject<DocumentBuilder>(args->get_Document()); | |
builder->MoveToMergeField(args->get_DocumentFieldName()); | |
// The name of the document to load and insert is stored in the field value. | |
auto subDoc = MakeObject<Document>(System::ObjectExt::Unbox<String>(args->get_FieldValue())); | |
InsertDocument(builder->get_CurrentParagraph(), subDoc); | |
// The paragraph that contained the merge field might be empty now, and you probably want to delete it. | |
if (!builder->get_CurrentParagraph()->get_HasChildNodes()) | |
{ | |
builder->get_CurrentParagraph()->Remove(); | |
} | |
// Indicate to the mail merge engine that we have inserted what we wanted. | |
args->set_Text(nullptr); | |
} | |
} | |
void ImageFieldMerging(SharedPtr<ImageFieldMergingArgs> args) override | |
{ | |
ASPOSE_UNUSED(args); | |
// Do nothing. | |
} | |
}; |
L’exemple de code suivant montre comment insérer un document dans le champ de fusion à l’aide du gestionnaire créé:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
auto mainDoc = MakeObject<Document>(MyDir + u"Document insertion 1.docx"); | |
mainDoc->get_MailMerge()->set_FieldMergingCallback(MakeObject<CloneAndCombineDocuments::InsertDocumentAtMailMergeHandler>()); | |
// The main document has a merge field in it called "Document_1". | |
// The corresponding data for this field contains a fully qualified path to the document. | |
// That should be inserted to this field. | |
mainDoc->get_MailMerge()->Execute(MakeArray<String>({u"Document_1"}), | |
MakeArray<SharedPtr<System::Object>>({System::ObjectExt::Box<String>(MyDir + u"Document insertion 2.docx")})); | |
mainDoc->Save(ArtifactsDir + u"CloneAndCombineDocuments.InsertDocumentAtMailMerge.doc"); |
Insérer un document dans un signet
Vous pouvez importer un fichier texte dans un document et l’insérer juste après un signet que vous avez défini dans le document. Pour ce faire, créez un paragraphe marqué d’un signet à l’endroit où vous souhaitez insérer le document.
L’exemple de codage suivant montre comment insérer le contenu d’un document dans un signet d’un autre document:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
auto mainDoc = MakeObject<Document>(MyDir + u"Document insertion 1.docx"); | |
auto subDoc = MakeObject<Document>(MyDir + u"Document insertion 2.docx"); | |
SharedPtr<Bookmark> bookmark = mainDoc->get_Range()->get_Bookmarks()->idx_get(u"insertionPlace"); | |
InsertDocument(bookmark->get_BookmarkStart()->get_ParentNode(), subDoc); | |
mainDoc->Save(ArtifactsDir + u"CloneAndCombineDocuments.InsertDocumentAtBookmark.docx"); |
Ajouter un document
Vous pouvez avoir un cas d’utilisation où vous devez inclure des pages supplémentaires d’un document à la fin d’un document existant. Pour ce faire, il vous suffit d’appeler la méthode AppendDocument pour ajouter un document à la fin d’un autre.
L’exemple de code suivant montre comment ajouter un document à la fin d’un autre document:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
auto dstDoc = MakeObject<Document>(); | |
dstDoc->get_FirstSection()->get_Body()->AppendParagraph(u"Destination document text. "); | |
auto srcDoc = MakeObject<Document>(); | |
srcDoc->get_FirstSection()->get_Body()->AppendParagraph(u"Source document text. "); | |
// Append the source document to the destination document. | |
// Pass format mode to retain the original formatting of the source document when importing it. | |
dstDoc->AppendDocument(srcDoc, ImportFormatMode::KeepSourceFormatting); | |
dstDoc->Save(ArtifactsDir + u"JoinAndAppendDocuments.KeepSourceFormatting.docx"); |
Importer et insérer des nœuds manuellement
Aspose.Words vous permet d’insérer et d’ajouter des documents automatiquement sans aucune exigence d’importation préalable. Cependant, si vous devez insérer ou ajouter un nœud spécifique de votre document, tel qu’une section ou un paragraphe, vous devez d’abord importer ce nœud manuellement.
Lorsque vous devez insérer ou ajouter une section ou un paragraphe à un autre, vous devez essentiellement importer les nœuds de la première arborescence de nœuds de document dans la seconde à l’aide de la méthode ImportNode. Après avoir importé vos nœuds, vous devez utiliser la méthode InsertAfter / InsertBefore pour insérer un nouveau nœud après/avant le nœud de référence. Cela vous permet de personnaliser le processus d’insertion en important des nœuds à partir d’un document et en les insérant à des positions données.
Vous pouvez également utiliser la méthode AppendChild pour ajouter un nouveau nœud spécifié à la fin de la liste des nœuds enfants, par exemple, si vous souhaitez ajouter du contenu au niveau du paragraphe plutôt qu’au niveau de la section.
L’exemple de code suivant montre comment importer manuellement des nœuds et les insérer après un nœud spécifique à l’aide de la méthode InsertAfter:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
/// <summary> | |
/// Inserts content of the external document after the specified node. | |
/// Section breaks and section formatting of the inserted document are ignored. | |
/// </summary> | |
/// <param name="insertionDestination">Node in the destination document after which the content | |
/// Should be inserted. This node should be a block level node (paragraph or table).</param> | |
/// <param name="docToInsert">The document to insert.</param> | |
static void InsertDocument(SharedPtr<Node> insertionDestination, SharedPtr<Document> docToInsert) | |
{ | |
if (insertionDestination->get_NodeType() == NodeType::Paragraph || insertionDestination->get_NodeType() == NodeType::Table) | |
{ | |
SharedPtr<CompositeNode> destinationParent = insertionDestination->get_ParentNode(); | |
auto importer = MakeObject<NodeImporter>(docToInsert, insertionDestination->get_Document(), ImportFormatMode::KeepSourceFormatting); | |
// Loop through all block-level nodes in the section's body, | |
// then clone and insert every node that is not the last empty paragraph of a section. | |
for (const auto& srcSection : System::IterateOver(docToInsert->get_Sections()->LINQ_OfType<SharedPtr<Section>>())) | |
{ | |
for (const auto& srcNode : System::IterateOver(srcSection->get_Body())) | |
{ | |
if (srcNode->get_NodeType() == NodeType::Paragraph) | |
{ | |
auto para = System::ExplicitCast<Paragraph>(srcNode); | |
if (para->get_IsEndOfSection() && !para->get_HasChildNodes()) | |
{ | |
continue; | |
} | |
} | |
SharedPtr<Node> newNode = importer->ImportNode(srcNode, true); | |
destinationParent->InsertAfter(newNode, insertionDestination); | |
insertionDestination = newNode; | |
} | |
} | |
} | |
else | |
{ | |
throw System::ArgumentException(u"The destination node should be either a paragraph or table."); | |
} | |
} |
Le contenu est importé dans le document de destination section par section, ce qui signifie que les paramètres, tels que la mise en page et les en-têtes ou pieds de page, sont conservés lors de l’importation. Il est également utile de noter que vous pouvez définir des paramètres de mise en forme lorsque vous insérez ou ajoutez un document pour spécifier comment deux documents sont joints.
Propriétés communes pour Insérer et ajouter des documents
À la fois InsertDocument et AppendDocument les méthodes acceptent ImportFormatMode et ImportFormatOptions comme paramètres d’entrée. Le ImportFormatMode vous permet de contrôler la façon dont le formatage du document est fusionné lorsque vous importez du contenu d’un document dans un autre en sélectionnant différents modes de formatage tels que UseDestinationStyles, KeepSourceFormatting et KeepDifferentStyles. Le ImportFormatOptions vous permet de sélectionner différentes options d’importation telles que IgnoreHeaderFooter, IgnoreTextBoxes, KeepSourceNumbering, MergePastedLists, et SmartStyleBehavior.
Aspose.Words vous permet d’ajuster la visualisation d’un document résultant lorsque deux documents sont ajoutés ensemble dans une opération d’insertion ou d’ajout à l’aide des propriétés Section et PageSetup. La propriété PageSetup contient tous les attributs d’une section tels que SectionStart, RestartPageNumbering, PageStartingNumber, Orientation, et d’autres. Le cas d’utilisation le plus courant consiste à définir la propriété SectionStart pour définir si le contenu ajouté apparaîtra sur la même page ou se divisera en une nouvelle.
L’exemple de code suivant montre comment ajouter un document à un autre tout en empêchant le contenu de se diviser sur deux pages:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git. | |
auto srcDoc = MakeObject<Document>(MyDir + u"Document source.docx"); | |
auto dstDoc = MakeObject<Document>(MyDir + u"Northwind traders.docx"); | |
// Set the source document to continue straight after the end of the destination document. | |
srcDoc->get_FirstSection()->get_PageSetup()->set_SectionStart(SectionStart::Continuous); | |
// Restart the page numbering on the start of the source document. | |
srcDoc->get_FirstSection()->get_PageSetup()->set_RestartPageNumbering(true); | |
srcDoc->get_FirstSection()->get_PageSetup()->set_PageStartingNumber(1); | |
// To ensure this does not happen when the source document has different page setup settings, make sure the | |
// settings are identical between the last section of the destination document. | |
// If there are further continuous sections that follow on in the source document, | |
// this will need to be repeated for those sections. | |
srcDoc->get_FirstSection()->get_PageSetup()->set_PageWidth(dstDoc->get_LastSection()->get_PageSetup()->get_PageWidth()); | |
srcDoc->get_FirstSection()->get_PageSetup()->set_PageHeight(dstDoc->get_LastSection()->get_PageSetup()->get_PageHeight()); | |
srcDoc->get_FirstSection()->get_PageSetup()->set_Orientation(dstDoc->get_LastSection()->get_PageSetup()->get_Orientation()); | |
// Iterate through all sections in the source document. | |
for (const auto& para : System::IterateOver<Paragraph>(srcDoc->GetChildNodes(NodeType::Paragraph, true))) | |
{ | |
para->get_ParagraphFormat()->set_KeepWithNext(true); | |
} | |
dstDoc->AppendDocument(srcDoc, ImportFormatMode::KeepSourceFormatting); | |
dstDoc->Save(ArtifactsDir + u"JoinAndAppendDocuments.DifferentPageSetup.docx"); |