Inserir e anexar documentos
Às vezes, é necessário combinar vários documentos em um. Você pode fazer isso manualmente ou pode usar o recurso Aspose.Words insert ou append.
A operação inserir permite inserir o conteúdo de documentos criados anteriormente em um novo ou existente.
Por sua vez, o recurso anexar permite adicionar um documento apenas no final de outro documento.
Este artigo explica como inserir ou anexar um documento a outro de maneiras diferentes e descreve as propriedades comuns que podem ser aplicadas ao inserir ou anexar documentos.
Inserir um documento
Como mencionado acima, em Aspose.Words um documento é representado como uma árvore de nós, e a operação de inserir um documento em outro é copiar nós da primeira árvore de documentos para a segunda.
Você pode inserir documentos em vários locais de diferentes maneiras. Por exemplo, você pode inserir um documento por meio de uma operação de substituição, um campo de mesclagem durante uma operação de mesclagem ou por meio de um marcador.
Você também pode usar o método InsertDocument ou InsertDocumentInline, que é semelhante a inserir um documento em Microsoft Word, para inserir um documento inteiro na posição atual do cursor sem qualquer importação anterior.
O exemplo de código a seguir mostra como inserir um documento usando o método InsertDocument:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document srcDoc = new Document(getMyDir() + "Document source.docx"); | |
Document dstDoc = new Document(getMyDir() + "Northwind traders.docx"); | |
DocumentBuilder builder = new DocumentBuilder(dstDoc); | |
builder.moveToDocumentEnd(); | |
builder.insertBreak(BreakType.PAGE_BREAK); | |
builder.insertDocument(srcDoc, ImportFormatMode.KEEP_SOURCE_FORMATTING); | |
builder.getDocument().save(getArtifactsDir() + "JoinAndAppendDocuments.insertDocument.docx"); |
O exemplo de código a seguir mostra como inserir um documento usando o método InsertDocumentInline:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
DocumentBuilder srcDoc = new DocumentBuilder(); | |
srcDoc.write("[src content]"); | |
// Create destination document. | |
DocumentBuilder dstDoc = new DocumentBuilder(); | |
dstDoc.write("Before "); | |
dstDoc.insertNode(new BookmarkStart(dstDoc.getDocument(), "src_place")); | |
dstDoc.insertNode(new BookmarkEnd(dstDoc.getDocument(), "src_place")); | |
dstDoc.write(" after"); | |
Assert.assertEquals("Before after", dstDoc.getDocument().getText().trim()); | |
// Insert source document into destination inline. | |
dstDoc.moveToBookmark("src_place"); | |
dstDoc.insertDocumentInline(srcDoc.getDocument(), ImportFormatMode.USE_DESTINATION_STYLES, new ImportFormatOptions()); | |
Assert.assertEquals("Before [src content] after", dstDoc.getDocument().getText().trim()); |
As subsecções seguintes descrevem as opções durante as quais pode inserir um documento noutro.
Inserir um documento durante a operação localizar e substituir
Pode inserir documentos enquanto executa operações de localização e substituição. Por exemplo, um documento pode conter parágrafos com o texto [INTRODUCTION] e [CONCLUSION]. Mas no documento final, é necessário substituir esses parágrafos pelo conteúdo obtido de outro documento externo. Para conseguir isso, você precisará criar um manipulador para o evento replace.
O exemplo de código a seguir mostra como criar um manipulador para o evento de substituição para usá-lo posteriormente no processo de inserção:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
private static class InsertDocumentAtReplaceHandler implements IReplacingCallback | |
{ | |
public /*ReplaceAction*/int /*IReplacingCallback.*/replacing(ReplacingArgs args) throws Exception | |
{ | |
Document subDoc = new Document(getMyDir() + "Document insertion 2.docx"); | |
// Insert a document after the paragraph, containing the match text. | |
Paragraph para = (Paragraph)args.getMatchNode().getParentNode(); | |
insertDocument(para, subDoc); | |
// Remove the paragraph with the match text. | |
para.remove(); | |
return ReplaceAction.SKIP; | |
} | |
} |
O exemplo de código a seguir mostra como inserir conteúdo de um documento em outro durante uma operação localizar e substituir:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document mainDoc = new Document(getMyDir() + "Document insertion 1.docx"); | |
// Set find and replace options. | |
FindReplaceOptions options = new FindReplaceOptions(); | |
{ | |
options.setDirection(FindReplaceDirection.BACKWARD); | |
options.setReplacingCallback(new InsertDocumentAtReplaceHandler()); | |
} | |
// Call the replace method. | |
mainDoc.getRange().replace(Pattern.compile("\\[MY_DOCUMENT\\]"), "", options); | |
mainDoc.save(getArtifactsDir() + "CloneAndCombineDocuments.InsertDocumentAtReplace.docx"); |
Inserir um documento durante a operação Mail Merge
É possível inserir um documento em um campo de mesclagem durante uma operação Mail Merge. Por exemplo, um modelo Mail Merge pode conter um campo de mesclagem, como [resumo]. Mas no documento final, é necessário inserir o conteúdo obtido de outro documento externo neste campo de mesclagem. Para conseguir isso, você precisará criar um manipulador para o evento de mesclagem.
O exemplo de código a seguir mostra como criar um manipulador para o evento de mesclagem para usá-lo posteriormente no processo de inserção:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
private static class InsertDocumentAtMailMergeHandler implements IFieldMergingCallback | |
{ | |
// This handler makes special processing for the "Document_1" field. | |
// The field value contains the path to load the document. | |
// We load the document and insert it into the current merge field. | |
public void /*IFieldMergingCallback.*/fieldMerging(FieldMergingArgs args) throws Exception | |
{ | |
if ("Document_1".equals(args.getDocumentFieldName())) | |
{ | |
// Use document builder to navigate to the merge field with the specified name. | |
DocumentBuilder builder = new DocumentBuilder(args.getDocument()); | |
builder.moveToMergeField(args.getDocumentFieldName()); | |
// The name of the document to load and insert is stored in the field value. | |
Document subDoc = new Document((String)args.getFieldValue()); | |
insertDocument(builder.getCurrentParagraph(), subDoc); | |
// The paragraph that contained the merge field might be empty now, and you probably want to delete it. | |
if (!builder.getCurrentParagraph().hasChildNodes()) | |
builder.getCurrentParagraph().remove(); | |
// Indicate to the mail merge engine that we have inserted what we wanted. | |
args.setText(null); | |
} | |
} | |
public void /*IFieldMergingCallback.*/imageFieldMerging(ImageFieldMergingArgs args) | |
{ | |
// Do nothing. | |
} | |
} |
O exemplo de código a seguir mostra como inserir um documento no campo de mesclagem usando o manipulador criado:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document mainDoc = new Document(getMyDir() + "Document insertion 1.docx"); | |
mainDoc.getMailMerge().setFieldMergingCallback(new 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.getMailMerge().execute(new String[] { "Document_1" }, new Object[] { getMyDir() + "Document insertion 2.docx" }); | |
mainDoc.save(getArtifactsDir() + "CloneAndCombineDocuments.InsertDocumentAtMailMerge.doc"); |
Inserir um documento no marcador
Pode importar um ficheiro de texto para um documento e inseri-lo logo após um marcador definido no documento. Para fazer isso, crie um parágrafo marcado onde deseja que o documento seja inserido.
O exemplo de codificação A seguir mostra como inserir o conteúdo de um documento em um marcador em outro documento:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document mainDoc = new Document(getMyDir() + "Document insertion 1.docx"); | |
Document subDoc = new Document(getMyDir() + "Document insertion 2.docx"); | |
Bookmark bookmark = mainDoc.getRange().getBookmarks().get("insertionPlace"); | |
insertDocument(bookmark.getBookmarkStart().getParentNode(), subDoc); | |
mainDoc.save(getArtifactsDir() + "CloneAndCombineDocuments.InsertDocumentAtBookmark.docx"); |
Anexar um documento
Você pode ter um caso de uso em que precise incluir páginas adicionais de um documento até o final de um documento existente. Para fazer isso, basta chamar o método AppendDocument para adicionar um documento ao final de outro.
O exemplo de código a seguir mostra como anexar um documento ao final de outro documento:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document dstDoc = new Document(); | |
dstDoc.getFirstSection().getBody().appendParagraph("Destination document text. "); | |
Document srcDoc = new Document(); | |
srcDoc.getFirstSection().getBody().appendParagraph("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.KEEP_SOURCE_FORMATTING); | |
dstDoc.save(getArtifactsDir() + "JoinAndAppendDocuments.KeepSourceFormatting.docx"); |
Importar e inserir nós manualmente
Aspose.Words permite inserir e anexar documentos automaticamente sem quaisquer requisitos de importação anteriores. No entanto, se você precisar inserir ou anexar um nó específico do seu documento, como uma seção ou um parágrafo, primeiro precisará importar esse nó manualmente.
Quando você precisa inserir ou anexar uma seção ou parágrafo a outra, você essencialmente precisa importar os nós da primeira árvore de nós do documento para a segunda usando o método ImportNode. Depois de importar seus nós, você precisa usar o método InsertAfter para inserir um novo nó após/antes do nó de referência. Isso permite que você personalize o processo de inserção importando nós de um documento e inserindo-o em determinadas posições.
Você também pode usar o método AppendChild para adicionar um novo nó especificado ao final da lista de nós filhos, por exemplo, se quiser acrescentar conteúdo no nível do parágrafo em vez de no nível da seção.
O exemplo de código a seguir mostra como importar nós manualmente e inseri-los após um nó específico usando o método InsertAfter:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.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> | |
private static void insertDocument(Node insertionDestination, Document docToInsert) | |
{ | |
if (insertionDestination.getNodeType() == NodeType.PARAGRAPH || insertionDestination.getNodeType() == NodeType.TABLE) | |
{ | |
CompositeNode destinationParent = insertionDestination.getParentNode(); | |
NodeImporter importer = | |
new NodeImporter(docToInsert, insertionDestination.getDocument(), ImportFormatMode.KEEP_SOURCE_FORMATTING); | |
// 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 (Section srcSection : docToInsert.getSections()) | |
for (Node srcNode : srcSection.getBody()) | |
{ | |
if (srcNode.getNodeType() == NodeType.PARAGRAPH) | |
{ | |
Paragraph para = (Paragraph)srcNode; | |
if (para.isEndOfSection() && !para.hasChildNodes()) | |
continue; | |
} | |
Node newNode = importer.importNode(srcNode, true); | |
destinationParent.insertAfter(newNode, insertionDestination); | |
insertionDestination = newNode; | |
} | |
} | |
else | |
{ | |
throw new IllegalArgumentException("The destination node should be either a paragraph or table."); | |
} | |
} |
O conteúdo é importado para o documento de destino seção por seção, o que significa que as configurações, como configuração de página e cabeçalhos ou rodapés, são preservadas durante a importação. Também é útil observar que você pode definir configurações de formatação ao inserir ou anexar um documento para especificar como dois documentos são unidos.
Propriedades comuns para inserir e anexar documentos
Ambos os métodos InsertDocument e AppendDocument aceitam ImportFormatMode e ImportFormatOptions como parâmetros de entrada. O ImportFormatMode permite controlar como a formatação do documento é mesclada ao importar conteúdo de um documento para outro, selecionando diferentes modos de formato, como UseDestinationStyles, KeepSourceFormatting e KeepDifferentStyles. O ImportFormatOptions permite selecionar diferentes opções de importação, tais como IgnoreHeaderFooter, IgnoreTextBoxes, KeepSourceNumbering, MergePastedLists, e SmartStyleBehavior.
Aspose.Words permite ajustar a visualização de um documento resultante quando dois documentos são adicionados em uma operação inserir ou acrescentar usando as propriedades Section e PageSetup. A propriedade PageSetup contém todos os atributos de uma seção, Como SectionStart, RestartPageNumbering, PageStartingNumber, Orientation, e outros. O caso de uso mais comum é definir a propriedade SectionStart para definir se o conteúdo adicionado aparecerá na mesma página ou será dividido em uma nova.
O exemplo de código a seguir mostra como anexar um documento a outro, evitando que o conteúdo se divida em duas páginas:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git. | |
Document srcDoc = new Document(getMyDir() + "Document source.docx"); | |
Document dstDoc = new Document(getMyDir() + "Northwind traders.docx"); | |
// Set the source document to continue straight after the end of the destination document. | |
srcDoc.getFirstSection().getPageSetup().setSectionStart(SectionStart.CONTINUOUS); | |
// Restart the page numbering on the start of the source document. | |
srcDoc.getFirstSection().getPageSetup().setRestartPageNumbering(true); | |
srcDoc.getFirstSection().getPageSetup().setPageStartingNumber(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.getFirstSection().getPageSetup().setPageWidth(dstDoc.getLastSection().getPageSetup().getPageWidth()); | |
srcDoc.getFirstSection().getPageSetup().setPageHeight(dstDoc.getLastSection().getPageSetup().getPageHeight()); | |
srcDoc.getFirstSection().getPageSetup().setOrientation(dstDoc.getLastSection().getPageSetup().getOrientation()); | |
// Iterate through all sections in the source document. | |
for (Paragraph para : (Iterable<Paragraph>) srcDoc.getChildNodes(NodeType.PARAGRAPH, true)) | |
{ | |
para.getParagraphFormat().setKeepWithNext(true); | |
} | |
dstDoc.appendDocument(srcDoc, ImportFormatMode.KEEP_SOURCE_FORMATTING); | |
dstDoc.save(getArtifactsDir() + "JoinAndAppendDocuments.DifferentPageSetup.docx"); |