<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
   <meta name="Author" content="IBM">
   <meta name="GENERATOR" content="Mozilla/4.75 [en] (WinNT; U) [Netscape]">
   <title>Package-level Javadoc</title>
</head>
<body>
Provides support for performing structural and textual
compare operations on arbitrary data and displaying the results.
<h2>
Package Specification</h2>
The class <tt>CompareUI</tt> defines the entry point to initiate a configurable
compare operation on arbitrary resources. The result of the compare is
opened into a compare editor where the details can be browsed and edited
in dynamically selected structure and content viewers.
<p>A compare operation must be implemented as a subclass of <tt>CompareEditorInput</tt>.
A <tt>CompareEditorInput</tt> runs a (potentially lengthy) compare operation
under progress monitor control, creates a UI for drilling-down into the
compare results, tracks the dirty state of the result in case of merge,
and saves any changes that occured during a merge.
<p>An instance of <tt>CompareConfiguration</tt> configures various UI aspects
of compare/merge viewers like title labels and images, or whether a side
of a merge viewer is editable. It is passed to the <tt>CompareEditorInput</tt>
on creation.
<p>When implementing a compare operation clients have to provide a tree
of <tt>IStructureComparator</tt> (see package org.eclipse.compare.structuremergeviewer)
and <tt>IStreamContentAccessor</tt> that can be passed as the input to
the differencing engine (org.eclipse.compare.structuremergeviewer.Differencer).
A <tt>ResourceNode</tt> is a convenience class that implements both interfaces
for Eclipse workbench resources (org.eclipse.core.resources.IResource).
It can be used without modification as the input to the differencing engine.
<p>The <tt>EditionSelectionDialog</tt> is a simple selection dialog where
one input element can be compared against a list of historic variants (<i>editions</i>)
of the same input element. The dialog can be used to implement functions
like <i>"Replace with Version"</i> or
<br><i>"Replace with Edition"</i> on workbench resources.
<p>In addition it is possible to specify a subsection of the input element
(e.g. a method in a Java source file) by means of a <i>path</i>. In this
case the dialog compares only the subsection (as specified by the path)
with the corresponding subsection in the list of editions. This functionality
can be used to implement <i>"Replace with Method Edition"</i> for the Java
language.
<p>The <tt>EditionSelectionDialog</tt> requires that the editions implement
the <tt>IStreamContentAccessor</tt> and <tt>IModificationDate</tt> interfaces.
The <tt>HistoryItem</tt> is a convenience class that implements these interfaces
for <tt>IFileState</tt> objects.
</body>
</html>
