Wijzigingen in een document volgen

De functionaliteit van track wijzigingen, ook wel bekend als review, stelt u in staat om wijzigingen in inhoud en formattering die door u of andere gebruikers. Deze track verandert functie met Aspose.Words ondersteunt track wijzigingen in Microsoft Word. Met deze functionaliteit heeft u toegang tot individuele revisies in uw document en past u verschillende eigenschappen toe.

Wanneer u de functie track changes inschakelt, zullen alle ingevoegde, verwijderde en gewijzigde elementen van het document visueel gemarkeerd worden met informatie over wie, wanneer en wat er veranderd is. Objecten die informatie over wat werd veranderd, worden genoemd Ga er bijvoorbeeld van uit dat u een document wilt bekijken en belangrijke wijzigingen wilt aanbrengen, dit kan betekenen dat u revisies moet maken. Ook moet u mogelijk opmerkingen invoegen om enkele wijzigingen te bespreken. Dat is waar veranderingen in documenten worden opgespoord.

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

Merk op dat het commentaar functie in Aspose.Words, en in Microsoft Word, kan worden geassocieerd met tracking wijzigingen. Vergeet echter niet dat opmerkingen volledig onafhankelijk zijn van het volgen van veranderingen.

Wat is een herziening?

Voordat je in revisies gaat duiken, laat je de betekenis van revisies uitleggen. A revision is een verandering die optreedt in een knooppunt van een document, terwijl een revisie groep, vertegenwoordigd door de RevisionGroup klasse, is een groep van opeenvolgende herzieningen die voorkomen in veel knooppunten van een document. Revisie is een hulpmiddel om veranderingen te volgen.

Revisies worden gebruikt in de tracking wijzigingen functie en binnen de vergelijking documenten functie, waar herzieningen verschijnen als gevolg van de vergelijking. Revisies binnen de tracking wijzigingen functie toont door wie en wat werd veranderd.

Merk op dat Microsoft Word laat u niet toe individuele herzieningen te bekijken, het geeft u alleen de mogelijkheid om sequentiële herzieningen als één entiteit te zien. Maar Aspose.Words lost deze beperking op met de RevisionGroup Klasse.

Aspose.Words ondersteunt verschillende revisietypes, evenals in Microsoft Word, zoals invoegen, verwijderen, formaat Wijzigen, StyleDefinition Verandering, en bewegen. Alle revisietypes zijn vertegenwoordigd met de RevisionType Samenvatting.

Merk op dat herzieningen een resultaat hebben dat vergelijkbaar is met Microsoft Word maar Aspose.Words opmaak niet detecteren tijdens het volgen van wijzigingen.

Wijzigingen starten en stoppen met volgen

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

Merk op dat de StartTrackingRevisions methode verandert de status van de TrackRevisions eigenschap en gebruikt zijn waarde niet voor het doel van revisie tracking. Bovendien, als een knooppunt werd verplaatst van de ene locatie naar de andere in het tracked document, dan zullen revisies worden gemaakt, inclusief move-from en move-to range.

Aan het einde van het proces voor het volgen van wijzigingen in uw document, kunt u zelfs alle herzieningen accepteren of weigeren om het document terug te draaien naar zijn oorspronkelijke vorm. Dit kan worden bereikt door AcceptAllRevisions of RejectAll methode. Bovendien kunt u elke revisie afzonderlijk accepteren of verwerpen door gebruik te maken van de Accept of Reject methode.

Alle veranderingen worden gevolgd voor één iteratie vanaf het moment dat je het proces start tot het moment dat je het stopt. De verbinding tussen verschillende iteraties wordt weergegeven als het volgende scenario: je maakt het trackingproces af, maakt vervolgens enkele wijzigingen aan en start opnieuw met het volgen van wijzigingen. Met dit scenario worden alle wijzigingen die je niet hebt geaccepteerd of afgewezen weer weergegeven.

Merk op dat de AcceptAllRevisions methode is vergelijkbaar met de Microsoft Word.

Het volgende voorbeeld van code laat zien hoe te werken met tracking wijzigingen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
Document doc = new Document();
Body body = doc.getFirstSection().getBody();
Paragraph para = body.getFirstParagraph();

// Add text to the first paragraph, then add two more paragraphs.
para.appendChild(new Run(doc, "Paragraph 1. "));
body.appendParagraph("Paragraph 2. ");
body.appendParagraph("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("John Doe", new Date());

// This paragraph is a revision and will have the according "IsInsertRevision" flag set.
para = body.appendParagraph("Paragraph 4. ");
if(para.isInsertRevision())
	System.out.println("isInsertRevision:" + para.isInsertRevision());

// Get the document's paragraph collection and remove a paragraph.
ParagraphCollection paragraphs = body.getParagraphs();
if(4 == paragraphs.getCount())
	System.out.println("count:" + paragraphs.getCount());

para = paragraphs.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.
if(4 == paragraphs.getCount())
	System.out.println("count:" + paragraphs.getCount());

if(para.isDeleteRevision())
	System.out.println("isDeleteRevision:" + para.isDeleteRevision());

// The delete revision paragraph is removed once we accept changes.
doc.acceptAllRevisions();
if(3 == paragraphs.getCount())
	System.out.println("count:" + paragraphs.getCount());

// Stopping the tracking of revisions makes this text appear as normal text.
// Revisions are not counted when the document is changed.
doc.stopTrackRevisions();

// Save the document.
doc.save(dataDir + "Document.Revisions.docx");

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

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java
// Generate document contents.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
builder.writeln("Paragraph 1");
builder.writeln("Paragraph 2");
builder.writeln("Paragraph 3");
builder.writeln("Paragraph 4");
builder.writeln("Paragraph 5");
builder.writeln("Paragraph 6");
Body body = doc.getFirstSection().getBody();
System.out.println("Paragraph count:" + body.getParagraphs().getCount());

// Start tracking revisions.
doc.startTrackRevisions("Author", new Date());

// Generate revisions when moving a node from one location to another.
Node node = body.getParagraphs().get(3);
Node endNode = body.getParagraphs().get(5).getNextSibling();
Node referenceNode = body.getParagraphs().get(0);
while (node != endNode)
{
	Node nextNode = node.getNextSibling();
	body.insertBefore(node, referenceNode);
	node = nextNode;
}

// Stop the process of tracking revisions.
doc.stopTrackRevisions();

// There are 3 additional paragraphs in the move-from range.
System.out.println("Paragraph count: " + body.getParagraphs().getCount());
doc.save(dataDir + "out.docx");

Wijzigingen beheren en opslaan als herzieningen

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

Aspose.Words kunt u controleren of een document een revisie heeft of niet met behulp van de HasRevision eigendom. Als u de wijzigingen in uw document niet automatisch hoeft te volgen via de StartTrackRevisions en StopTrackRevisions methoden, dan kunt u de TrackRevisions eigenschap om te controleren of de wijzigingen worden gevolgd tijdens het bewerken van een document in Microsoft Word en opgeslagen als herzieningen.

De TrackRevisions feature maakt revisies in plaats van echt DOM veranderingen. Maar de herzieningen zelf zijn apart. Bijvoorbeeld, Als u een paragraaf verwijdert, Aspose.Words maken het als een herziening, markeren als verwijdering, in plaats van verwijderen.

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

Merk op dat er geen verband is tussen de herzieningen zelf en de TrackRevisions eigendom. Daarnaast kunt u revisies accepteren/verwerpen ongeacht de functie trackingwijzigingen.

Het volgende voorbeeld van code 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-Java
// Open a blank document.
Document doc = new Document();

// Insert an inline shape without tracking revisions.
Shape shape = new Shape(doc, ShapeType.CUBE);
shape.setWrapType(WrapType.INLINE);
shape.setWidth(100.0);
shape.setHeight(100.0);
doc.getFirstSection().getBody().getFirstParagraph().appendChild(shape);

// Start tracking revisions and then insert another shape.
doc.startTrackRevisions("John Doe");
shape = new Shape(doc, ShapeType.SUN);
shape.setWrapType(WrapType.INLINE);
shape.setWidth(100.0);
shape.setHeight(100.0);
doc.getFirstSection().getBody().getFirstParagraph().appendChild(shape);

// Get the document's shape collection which includes just the two shapes we added.
Node[] shapes = doc.getChildNodes(NodeType.SHAPE, true).toArray();
if(2 == shapes.length)
	System.out.println("Shapes Count:" + shapes.length);

// Remove the first shape.
shapes[0].remove();

Shape sh = (Shape) shapes[0];
// Because we removed that shape while changes were being tracked, the shape counts as a delete revision.
if(ShapeType.CUBE == sh.getShapeType())
	System.out.println("Shape is CUBE");
		
if(sh.isDeleteRevision())
	System.out.println("isDeleteRevision:" + sh.isDeleteRevision());

// And we inserted another shape while tracking changes, so that shape will count as an insert revision.
sh = (Shape) shapes[1];
if(ShapeType.SUN == sh.getShapeType())
	System.out.println("Shape is SUN");
		
if(sh.isInsertRevision())
	System.out.println("IsInsertRevision:" + sh.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 = new Document(dataDir + "Revision shape.docx");

Node[] nc = doc.getChildNodes(NodeType.SHAPE, true).toArray();
if(4 == nc.length)
	System.out.println("Shapes Count:" + nc.length);

Shape mvr = (Shape) nc[0];
// This is the move to revision, also the shape at its arrival destination.
if(mvr.isMoveFromRevision())
	System.out.println("isMoveFromRevision:" + mvr.isMoveFromRevision());
		
if(mvr.isMoveToRevision())
	System.out.println("isMoveToRevision:" + mvr.isMoveToRevision());
		
mvr = (Shape) nc[1];
// This is the move from revision, which is the shape at its original location.
if(mvr.isMoveFromRevision())
	System.out.println("isMoveFromRevision:" + mvr.isMoveFromRevision());
		
if(mvr.isMoveToRevision())
	System.out.println("isMoveToRevision:" + mvr.isMoveToRevision());