Wijzigingen in een Document bijhouden

Met de functionaliteit van track changes, ook wel reviewing genoemd, kunt u wijzigingen in inhoud en opmaak door u of andere gebruikers bijhouden. Deze functie Wijzigingen bijhouden met Aspose.Words ondersteunt wijzigingen bijhouden in Microsoft Word. Met deze functionaliteit hebt u toegang tot afzonderlijke revisies in uw document en kunt u verschillende eigenschappen daarop toepassen.

Wanneer u de functie Wijzigingen bijhouden inschakelt, worden alle ingevoegde, verwijderde en gewijzigde elementen van het document visueel gemarkeerd met informatie over wie, wanneer en wat is gewijzigd. Objecten die de informatie bevatten over wat er is gewijzigd, worden “tracking changes"genoemd. Stel bijvoorbeeld dat u een document wilt bekijken en belangrijke wijzigingen wilt aanbrengen – dit kan betekenen dat u herzieningen moet aanbrengen. Mogelijk moet u ook opmerkingen invoegen om enkele wijzigingen te bespreken. Dat is waar het bijhouden van wijzigingen in documenten binnenkomt.

In dit artikel wordt uitgelegd hoe u wijzigingen die door veel beoordelaars in hetzelfde document zijn gemaakt, kunt beheren en bijhouden, evenals de eigenschappen voor het bijhouden van wijzigingen.

Merk op dat de commentaarfunctie in Aspose.Words, evenals in Microsoft Word, kan worden gekoppeld aan het bijhouden van wijzigingen. Houd er echter rekening mee dat opmerkingen volledig onafhankelijk zijn van het bijhouden van wijzigingen.

Wat Is een revisie

Voordat we ingaan op herzieningen, laten we de Betekenis van herzieningen uitleggen. Een revision is een wijziging die optreedt in één knooppunt van een document, terwijl een revisiegroep, vertegenwoordigd door de klasse RevisionGroup, een groep opeenvolgende herzieningen is die voorkomt in veel knooppunten van een document. Revisie is een tool voor het bijhouden van wijzigingen.

Revisies worden gebruikt in de functie Wijzigingen bijhouden en in de functie documenten vergelijken, waar revisies worden weergegeven als gevolg van de vergelijking. Revisies in de functie tracking changes laten dus zien door wie en wat er is gewijzigd.

Merk op dat Microsoft Word u niet toestaat om individuele herzieningen te bekijken, maar u alleen toestaat om opeenvolgende herzieningen als één entiteit te bekijken. Maar Aspose.Words Lost deze beperking op met de RevisionGroup Klasse.

Aspose.Words ondersteunt verschillende revisietypen, evenals in Microsoft Word, zoals Invoegen, Verwijderen, FormatChange, StyleDefinitionChange en verplaatsen. Alle revisietypen worden weergegeven met de RevisionType opsomming.

Merk op dat revisies een resultaat hebben dat vergelijkbaar is met Microsoft Word, maar dat Aspose.Words de opmaak niet detecteert tijdens het bijhouden van wijzigingen.

Wijzigingen bijhouden starten en stoppen

Het bewerken van een document telt meestal niet als een revisie totdat u het begint te volgen. Met Aspose.Words kunt u automatisch alle wijzigingen in uw document bijhouden met eenvoudige stappen. U kunt het proces van het bijhouden van wijzigingen eenvoudig starten met de methode StartTrackRevisions. Als u het proces van het bijhouden van wijzigingen moet stoppen, zodat toekomstige bewerkingen niet als revisies worden beschouwd, moet u de methode StopTrackRevisions gebruiken.

Merk op dat de methode StartTrackingRevisions de status van de eigenschap TrackRevisions niet wijzigt en de waarde ervan niet gebruikt voor het bijhouden van revisies. Als een knooppunt van de ene locatie naar de andere in het bijgehouden document is verplaatst, worden bovendien verplaatsingsherzieningen gemaakt, inclusief verplaatsingsbereik en verplaatsingsbereik.

Aan het einde van het proces voor het bijhouden van wijzigingen in uw document kunt u zelfs alle herzieningen accepteren of weigeren om het document terug te brengen naar de oorspronkelijke vorm. Dit kan worden bereikt door de AcceptAllRevisions of RejectAll methode te gebruiken. Bovendien kunt u elke herziening afzonderlijk accepteren of afwijzen met behulp van de methode Accept of Reject.

Alle wijzigingen worden bijgehouden voor één iteratie vanaf het moment dat u het proces start tot het moment dat u het stopt. De verbinding tussen verschillende iteraties wordt weergegeven als het volgende scenario: U voltooit het trackingproces, brengt vervolgens enkele wijzigingen aan en begint opnieuw met het bijhouden van wijzigingen. In dit scenario worden alle wijzigingen die u niet hebt geaccepteerd of afgewezen, opnieuw weergegeven.

Merk op dat de AcceptAllRevisions methode vergelijkbaar is met de “alle wijzigingen accepteren” in Microsoft Word.

Het volgende codevoorbeeld laat zien hoe u kunt werken met het bijhouden van wijzigingen:

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

Het volgende codevoorbeeld laat zien hoe revisies worden gegenereerd wanneer een knooppunt wordt verplaatst binnen een bijgehouden document:

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

Wijzigingen beheren en opslaan als revisies

Met de functie vorige wijzigingen bijhouden kunt u begrijpen welke wijzigingen in uw document zijn aangebracht en wie deze wijzigingen heeft aangebracht. Terwijl u de functie TrackRevisions gebruikt, dwingt u wijzigingen in uw document op te slaan als revisies.

Met Aspose.Words kunt u controleren of een document een revisie heeft of niet met behulp van de eigenschap HasRevision. Als u de wijzigingen in uw document niet automatisch hoeft bij te houden via de methoden StartTrackRevisions en StopTrackRevisions, kunt u de eigenschap TrackRevisions gebruiken om te controleren of de wijzigingen worden bijgehouden tijdens het bewerken van een document in Microsoft Word en worden opgeslagen als revisies.

De functie TrackRevisions maakt revisies in plaats van echte DOM wijzigingen. Maar de herzieningen zelf zijn gescheiden. Als u bijvoorbeeld een alinea verwijdert, voert u Aspose.Words uit als een revisie en markeert u deze als verwijdering in plaats van deze te verwijderen.

Bovendien kunt u met Aspose.Words Controleren of een object is ingevoegd, verwijderd of gewijzigd opmaak met behulp van de IsDeleteRevision, IsFormatRevision, IsInsertRevision, IsMoveFromRevision, en IsMoveToRevision eigenschappen.

Merk op dat er geen verband is tussen de revisies zelf en de eigenschap TrackRevisions. Bovendien kunt u revisies accepteren/weigeren, ongeacht de functie voor het bijhouden van wijzigingen.

Het volgende codevoorbeeld laat zien hoe verschillende eigenschappen met revisies kunnen worden toegepast:

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());