Vkládání a připojování dokumentů

Někdy je nutné kombinovat několik dokumentů do jednoho. Můžete to udělat ručně nebo můžete použít funkci Aspose.Words vložit nebo připojit.

Operace vložení umožňuje vložit obsah dříve vytvořených dokumentů do nového nebo existujícího.

Funkce Připojit zase umožňuje přidat dokument pouze na konec jiného dokumentu.

Tento článek vysvětluje, jak vložit nebo připojit dokument k jinému dokumentu různými způsoby, a popisuje společné vlastnosti, které můžete použít při vkládání nebo připojování dokumentů.

Vložení dokumentu

Jak bylo uvedeno výše, v Aspose.Words je dokument reprezentován jako strom uzlů a operací vkládání jednoho dokumentu do druhého je kopírování uzlů z prvního stromu dokumentů do druhého.

Dokumenty můžete vkládat na různá místa různými způsoby. Můžete například vložit dokument pomocí operace nahrazení, pole sloučení během operace sloučení nebo pomocí záložky.

Můžete také použít metodu InsertDocument, která je podobná vložení dokumentu do Microsoft Word, k vložení celého dokumentu na aktuální pozici kurzoru bez předchozího importu.

Následující příklad kódu ukazuje, jak vložit dokument pomocí metody 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");

Následující podsekce popisují možnosti, během kterých můžete vložit jeden dokument do druhého.

Vložení dokumentu během operace najít a nahradit

Dokumenty můžete vkládat při provádění operací najít a nahradit. Například dokument může obsahovat odstavce s textem [INTRODUCTION] a [CONCLUSION]. V konečném dokumentu však musíte tyto odstavce nahradit obsahem získaným z jiného externího dokumentu. Chcete-li toho dosáhnout, budete muset vytvořit obslužnou rutinu pro událost nahradit.

Následující příklad kódu ukazuje, jak vytvořit obslužnou rutinu pro událost nahrazující ji použít později v procesu vkládání:

// 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;
    }
};

Následující příklad kódu ukazuje, jak vložit obsah jednoho dokumentu do druhého během operace najít a nahradit:

// 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");

Vložení dokumentu během operace Mail Merge

Dokument můžete vložit do pole sloučení během operace Mail Merge. Například šablona Mail Merge může obsahovat pole sloučení ,například [souhrn]. V konečném dokumentu však musíte do tohoto pole sloučení vložit obsah získaný z jiného externího dokumentu. Chcete-li toho dosáhnout, budete muset vytvořit obslužnou rutinu pro událost sloučení.

Následující příklad kódu ukazuje, jak vytvořit obslužnou rutinu pro událost sloučení, která ji později použije v procesu vkládání:

// 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.
    }
};

Následující příklad kódu ukazuje, jak vložit dokument do pole sloučení pomocí vytvořené obslužné rutiny:

// 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");

Vložení dokumentu do záložky

Textový soubor můžete importovat do dokumentu a vložit jej hned za záložku, kterou jste v dokumentu definovali. Chcete-li to provést, vytvořte odstavec označený záložkou, kam chcete dokument vložit.

Následující příklad kódování ukazuje, jak vložit obsah jednoho dokumentu do záložky v jiném dokumentu:

// 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");

Všimněte si, že záložka by neměla obsahovat více odstavců nebo textu, které chcete, aby se zobrazovaly v konečném výsledném dokumentu.

Připojit dokument

Můžete mít případ použití, kdy potřebujete zahrnout další stránky z dokumentu na konec existujícího dokumentu. Chcete-li to provést, stačí zavolat metodu AppendDocument a přidat dokument na konec jiného.

Všimněte si, že AppendChild je metoda úrovně uzlu v dokumentu. Můžete například vytvořit odstavec, nastavit vlastnosti formátování a poté jej připojit jako podřízený k tělu pomocí metody AppendChild.

Následující příklad kódu ukazuje, jak připojit dokument na konec jiného dokumentu:

// 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");

Importovat a vkládat uzly ručně

Aspose.Words umožňuje automaticky vkládat a připojovat dokumenty bez předchozích požadavků na Import. Pokud však potřebujete vložit nebo připojit konkrétní uzel dokumentu, například oddíl nebo odstavec, musíte nejprve tento uzel importovat ručně.

Pokud potřebujete vložit nebo připojit jeden oddíl nebo odstavec k druhému, musíte v podstatě importovat uzly prvního stromu uzlů dokumentu do druhého pomocí metody ImportNode. Po importu uzlů musíte použít metodu InsertAfter / InsertBefore k vložení nového uzlu za / před referenční uzel. To vám umožní přizpůsobit proces vkládání importem uzlů z dokumentu a jeho vložením na dané pozice.

Metodu AppendChild můžete také použít k přidání nového zadaného uzlu na konec seznamu podřízených uzlů, například pokud chcete připojit obsah na úrovni odstavce místo na úrovni oddílu.

Následující příklad kódu ukazuje, jak ručně importovat uzly a vložit je za konkrétní uzel pomocí metody 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.");
    }
}

Import vytvoří nový uzel, který je kopií původního uzlu a je vhodný pro vložení do cílového dokumentu.

Obsah se importuje do cílového dokumentu po jednotlivých částech, což znamená, že nastavení, jako je nastavení stránky a záhlaví nebo zápatí, jsou během importu zachována. Je také užitečné poznamenat, že při vkládání nebo připojování dokumentu můžete definovat nastavení formátování, abyste určili, jak jsou dva dokumenty spojeny dohromady.

Společné vlastnosti pro vkládání a připojování dokumentů

Oba InsertDocument a AppendDocument metody přijímají ImportFormatMode a ImportFormatOptions jako vstupní parametry. ImportFormatMode vám umožňuje řídit způsob sloučení formátování dokumentu při importu obsahu z jednoho dokumentu do druhého výběrem různých režimů formátu, například UseDestinationStyles, KeepSourceFormatting a KeepDifferentStyles. ImportFormatOptions umožňuje vybrat různé možnosti importu, například IgnoreHeaderFooter, IgnoreTextBoxes, KeepSourceNumbering, MergePastedLists, a SmartStyleBehavior.

Aspose.Words umožňuje upravit vizualizaci výsledného dokumentu, když jsou dva dokumenty sečteny dohromady v operaci vložení nebo připojení pomocí vlastností Section a PageSetup. Vlastnost PageSetup obsahuje všechny atributy sekce, jako například SectionStart, RestartPageNumbering, PageStartingNumber, Orientation, a další. Nejběžnějším případem použití je nastavit vlastnost SectionStart tak, aby definovala, zda se přidaný obsah objeví na stejné stránce nebo rozdělí na novou.

Všimněte si, že vlastnosti Section a PageSetup nekontrolují, jak jsou dva dokumenty vloženy/připojeny dohromady. Umožňují pouze změnit vzhled výsledkového dokumentu.

Následující příklad kódu ukazuje, jak připojit jeden dokument k druhému a zároveň zabránit rozdělení obsahu na dvě stránky:

// 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");