Acompanhar alterações num documento
A funcionalidade de rastrear alterações, também conhecida como revisão, permite que você rastreie alterações no conteúdo e na formatação feitas por você ou por outros usuários. Este recurso de alterações de faixa com Aspose.Words suporta alterações de faixa em Microsoft Word. Com essa funcionalidade, você pode acessar revisões individuais em seu documento e aplicar propriedades diferentes a elas.
Ao ativar o recurso rastrear alterações, todos os elementos inseridos, excluídos e modificados do documento serão destacados visualmente com informações sobre por quem, quando e o que foi alterado. Objetos que carregam as informações sobre o que foi alterado são chamados de"rastreamento de alterações". Por exemplo, suponha que você deseja revisar um documento e fazer alterações importantes – isso pode significar que você precisa fazer revisões. Além disso, pode ser necessário inserir comentários para discutir algumas das alterações. É aí que entra o acompanhamento das alterações nos documentos.
Este artigo explica como gerir e acompanhar as alterações criadas por muitos revisores no mesmo documento, bem como as propriedades para acompanhar as alterações.
O que é uma revisão
Antes de mergulhar nas revisões, vamos explicar o significado das revisões. A revision é uma alteração que ocorre em um nó de um documento, enquanto um grupo de revisão, representado pela classe RevisionGroup, é um grupo de revisões sequenciais que ocorrem em muitos nós de um documento. Basicamente, a revisão é uma ferramenta para acompanhar as alterações.
As revisões são utilizadas na funcionalidade acompanhar alterações e na funcionalidade comparar documentos, em que as revisões aparecem como resultado da comparação. Portanto, as revisões no recurso de rastreamento de alterações mostram por quem e o que foi alterado.
Aspose.Words suporta diferentes tipos de revisão, bem como em Microsoft Word, Como inserção, exclusão, FormatChange, StyleDefinitionChange e movimentação. Todos os tipos de revisão são representados com a enumeração RevisionType.
Iniciar e parar o acompanhamento das alterações
A edição de um documento geralmente não conta como uma revisão até que você comece a rastreá-lo. Aspose.Words permite-lhe controlar automaticamente todas as alterações no seu documento com passos simples. Você pode facilmente iniciar o processo de rastreamento de alterações usando o método StartTrackRevisions. Se você precisar interromper o processo de rastreamento de alterações para que quaisquer edições futuras não sejam consideradas revisões, você precisará usar o método StopTrackRevisions.
StartTrackingRevisions
não altera o status da propriedade TrackRevisions e não usa seu valor para o objetivo de rastreamento de revisão. Além disso, se um nó foi movido de um local para outro dentro do documento rastreado, as revisões de movimentação serão criadas, incluindo o intervalo de mudança de e de mudança para.
No final do processo de acompanhamento de alterações no seu documento, terá a capacidade de aceitar todas as revisões ou rejeitá-las para reverter o documento para a sua forma original. Isto pode ser conseguido utilizando o método AcceptAllRevisions ou RejectAll. Além disso, você pode aceitar ou rejeitar cada revisão separadamente usando o método Accept ou Reject.
Todas as alterações serão rastreadas para uma iteração, desde o momento em que você inicia o processo até o momento em que o interrompe. A conexão entre diferentes iterações é representada como o seguinte cenário: você conclui o processo de Rastreamento, faz algumas alterações e começa a rastrear as alterações novamente. Com esse cenário, todas as alterações que você não aceitou ou rejeitou serão exibidas novamente.
AcceptAllRevisions
é semelhante ao" aceitar todas as alterações " em Microsoft Word.
O exemplo de código a seguir mostra como trabalhar com o rastreamento de alterações:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
auto doc = System::MakeObject<Document>(); | |
System::SharedPtr<Body> body = doc->get_FirstSection()->get_Body(); | |
System::SharedPtr<Paragraph> para = body->get_FirstParagraph(); | |
// Add text to the first paragraph, then add two more paragraphs. | |
para->AppendChild(System::MakeObject<Run>(doc, u"Paragraph 1. ")); | |
body->AppendParagraph(u"Paragraph 2. "); | |
body->AppendParagraph(u"Paragraph 3. "); | |
// We have three paragraphs, none of which registered as any type of revision | |
// If we add/remove any content in the document while tracking revisions, | |
// they will be displayed as such in the document and can be accepted/rejected. | |
doc->StartTrackRevisions(u"John Doe", System::DateTime::get_Now()); | |
// This paragraph is a revision and will have the according "IsInsertRevision" flag set. | |
para = body->AppendParagraph(u"Paragraph 4. "); | |
ASSERT_TRUE(para->get_IsInsertRevision()); | |
// Get the document's paragraph collection and remove a paragraph. | |
System::SharedPtr<ParagraphCollection> paragraphs = body->get_Paragraphs(); | |
ASSERT_EQ(4, paragraphs->get_Count()); | |
para = paragraphs->idx_get(2); | |
para->Remove(); | |
// Since we are tracking revisions, the paragraph still exists in the document, will have the "IsDeleteRevision" set | |
// and will be displayed as a revision in Microsoft Word, until we accept or reject all revisions. | |
ASSERT_EQ(4, paragraphs->get_Count()); | |
ASSERT_TRUE(para->get_IsDeleteRevision()); | |
// The delete revision paragraph is removed once we accept changes. | |
doc->AcceptAllRevisions(); | |
ASSERT_EQ(3, paragraphs->get_Count()); | |
ASSERT_EQ(0, para->get_Count()); | |
// Stopping the tracking of revisions makes this text appear as normal text. | |
// Revisions are not counted when the document is changed. | |
doc->StopTrackRevisions(); | |
System::String outputPath = outputDataDir + u"WorkingWithRevisions.AcceptRevisions.doc"; | |
doc->Save(outputPath); |
O exemplo de código a seguir mostra como as revisões são geradas quando um nó é movido dentro de um documento rastreado:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
auto doc = System::MakeObject<Document>(); | |
auto builder = System::MakeObject<DocumentBuilder>(doc); | |
builder->Writeln(u"Paragraph 1"); | |
builder->Writeln(u"Paragraph 2"); | |
builder->Writeln(u"Paragraph 3"); | |
builder->Writeln(u"Paragraph 4"); | |
builder->Writeln(u"Paragraph 5"); | |
builder->Writeln(u"Paragraph 6"); | |
System::SharedPtr<Body> body = doc->get_FirstSection()->get_Body(); | |
std::cout << "Paragraph count: " << body->get_Paragraphs()->get_Count() << std::endl; | |
// Start tracking revisions. | |
doc->StartTrackRevisions(u"Author", System::DateTime(2020, 12, 23, 14, 0, 0)); | |
// Generate revisions when moving a node from one location to another. | |
System::SharedPtr<Node> node = body->get_Paragraphs()->idx_get(3); | |
System::SharedPtr<Node> endNode = body->get_Paragraphs()->idx_get(5)->get_NextSibling(); | |
System::SharedPtr<Node> referenceNode = body->get_Paragraphs()->idx_get(0); | |
while (node != endNode) | |
{ | |
System::SharedPtr<Node> nextNode = node->get_NextSibling(); | |
body->InsertBefore(node, referenceNode); | |
node = nextNode; | |
} | |
// Stop the process of tracking revisions. | |
doc->StopTrackRevisions(); | |
// There are 3 additional paragraphs in the move-from range. | |
std::cout << "Paragraph count: " << body->get_Paragraphs()->get_Count() << std::endl; | |
System::String outputPath = outputDataDir + u"WorkingWithRevisions.MoveNodeInTrackedDocument.pdf"; | |
doc->Save(outputPath); |
Gerir e armazenar alterações como revisões
Com o recurso de rastreamento de alterações anterior, você pode entender quais alterações foram feitas em seu documento e quem as fez. Enquanto com o recurso TrackRevisions, Você força quaisquer alterações em seu documento a serem armazenadas como revisões.
Aspose.Words permite verificar se um documento tem uma revisão ou não utilizando a propriedade HasRevision. Se você não precisar rastrear automaticamente as alterações em seu documento por meio dos métodos StartTrackRevisions e StopTrackRevisions, poderá usar a propriedade TrackRevisions
para verificar se as alterações são rastreadas durante a edição de um documento em Microsoft Word e armazenadas como revisões.
O recurso TrackRevisions
faz revisões em vez de alterações reais DOM. Mas as revisões em si são separadas. Por exemplo, se você excluir qualquer parágrafo, Aspose.Words Faça-o como uma revisão, marcando-o como exclusão, em vez de excluí-lo.
Além disso, Aspose.Words permite verificar se um objeto foi inserido, excluído ou alterado IsDeleteRevision, IsFormatRevision, IsInsertRevision, IsMoveFromRevision, e IsMoveToRevision propriedades.
TrackRevisions
. Além disso, você pode aceitar/rejeitar revisões, independentemente do recurso de rastreamento de alterações.
O exemplo de código a seguir mostra como aplicar propriedades diferentes com revisões:
For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C | |
auto doc = System::MakeObject<Document>(); | |
// Insert an inline shape without tracking revisions. | |
ASSERT_FALSE(doc->get_TrackRevisions()); | |
auto shape = System::MakeObject<Shape>(doc, ShapeType::Cube); | |
shape->set_WrapType(WrapType::Inline); | |
shape->set_Width(100.0); | |
shape->set_Height(100.0); | |
doc->get_FirstSection()->get_Body()->get_FirstParagraph()->AppendChild(shape); | |
// Start tracking revisions and then insert another shape. | |
doc->StartTrackRevisions(u"John Doe"); | |
shape = System::MakeObject<Shape>(doc, ShapeType::Sun); | |
shape->set_WrapType(WrapType::Inline); | |
shape->set_Width(100.0); | |
shape->set_Height(100.0); | |
doc->get_FirstSection()->get_Body()->get_FirstParagraph()->AppendChild(shape); | |
// Get the document's shape collection which includes just the two shapes we added. | |
auto shapes = doc->GetChildNodes(NodeType::Shape, true)->LINQ_Cast<System::SharedPtr<Shape>>()->LINQ_ToList(); | |
ASSERT_EQ(2, shapes->get_Count()); | |
// Remove the first shape. | |
shapes->idx_get(0)->Remove(); | |
// Because we removed that shape while changes were being tracked, the shape counts as a delete revision. | |
ASSERT_EQ(ShapeType::Cube, shapes->idx_get(0)->get_ShapeType()); | |
ASSERT_TRUE(shapes->idx_get(0)->get_IsDeleteRevision()); | |
// And we inserted another shape while tracking changes, so that shape will count as an insert revision. | |
ASSERT_EQ(ShapeType::Sun, shapes->idx_get(1)->get_ShapeType()); | |
ASSERT_TRUE(shapes->idx_get(1)->get_IsInsertRevision()); | |
// The document has one shape that was moved, but shape move revisions will have two instances of that shape. | |
// One will be the shape at its arrival destination and the other will be the shape at its original location. | |
doc = System::MakeObject<Document>(inputDataDir + u"Revision shape.docx"); | |
shapes = doc->GetChildNodes(NodeType::Shape, true)->LINQ_Cast<System::SharedPtr<Shape>>()->LINQ_ToList(); | |
ASSERT_EQ(4, shapes->get_Count()); | |
// This is the move to revision, also the shape at its arrival destination. | |
ASSERT_FALSE(shapes->idx_get(0)->get_IsMoveFromRevision()); | |
ASSERT_TRUE(shapes->idx_get(0)->get_IsMoveToRevision()); | |
// This is the move from revision, which is the shape at its original location. | |
ASSERT_TRUE(shapes->idx_get(1)->get_IsMoveFromRevision()); | |
ASSERT_FALSE(shapes->idx_get(1)->get_IsMoveToRevision()); |