Public Git Hosting - EMFCompare2.git/blob - plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/EMFCompareStructureMergeViewer.java

1 /*******************************************************************************

4 * are made available under the terms of the Eclipse Public License v1.0

5 * which accompanies this distribution, and is available at

6 * http://www.eclipse.org/legal/epl-v10.html

7 *

8 * Contributors:

9 * Obeo - initial API and implementation

10 * Michael Borkowski - bug 467191

11 * Philip Langer - bug 462884, 516576

12 * Stefan Dirix - bugs 473985, 474030

13 * Martin Fleck - bug 497066, 483798, 514767, 514415

14 * Alexandra Buzila - bug 513931

15 *******************************************************************************/

package org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer;

import static com.google.common.base.Predicates.instanceOf;

import static com.google.common.collect.Iterables.any;

import static org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.EMFCompareStructureMergeViewerContentProvider.CallbackType.IN_UI_ASYNC;

import static org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.EMFCompareStructureMergeViewerContentProvider.CallbackType.IN_UI_SYNC;

import com.google.common.base.Function;

import com.google.common.base.Objects;

import com.google.common.base.Predicate;

import com.google.common.base.Throwables;

import com.google.common.collect.Iterables;

import com.google.common.collect.Iterators;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.common.eventbus.Subscribe;

33 import java.util.ArrayList;

34 import java.util.Collection;

35 import java.util.Collections;

36 import java.util.EnumSet;

37 import java.util.EventObject;

38 import java.util.Iterator;

39 import java.util.List;

40 import java.util.Map;

41 import java.util.Set;

import org.eclipse.compare.CompareUI;

import org.eclipse.compare.CompareViewerPane;

import org.eclipse.compare.CompareViewerSwitchingPane;

import org.eclipse.compare.ICompareInputLabelProvider;

import org.eclipse.compare.INavigatable;

import org.eclipse.compare.ITypedElement;

import org.eclipse.compare.ResourceNode;

import org.eclipse.compare.structuremergeviewer.DiffNode;

import org.eclipse.compare.structuremergeviewer.ICompareInput;

import org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener;

import org.eclipse.core.resources.IStorage;

import org.eclipse.core.resources.ResourceAttributes;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubMonitor;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.emf.common.command.Command;

import org.eclipse.emf.common.command.CommandStack;

import org.eclipse.emf.common.command.CommandStackListener;

import org.eclipse.emf.common.notify.Adapter;

import org.eclipse.emf.common.notify.Notifier;

import org.eclipse.emf.common.ui.CommonUIPlugin;

import org.eclipse.emf.common.util.BasicDiagnostic;

import org.eclipse.emf.common.util.BasicMonitor;

import org.eclipse.emf.common.util.Diagnostic;

import org.eclipse.emf.compare.Comparison;

import org.eclipse.emf.compare.ConflictKind;

import org.eclipse.emf.compare.Diff;

import org.eclipse.emf.compare.DifferenceState;

import org.eclipse.emf.compare.EMFCompare;

import org.eclipse.emf.compare.EMFCompare.Builder;

import org.eclipse.emf.compare.Match;

import org.eclipse.emf.compare.MatchResource;

import org.eclipse.emf.compare.adapterfactory.context.IContextTester;

import org.eclipse.emf.compare.command.ICompareCopyCommand;

import org.eclipse.emf.compare.domain.ICompareEditingDomain;

import org.eclipse.emf.compare.domain.impl.EMFCompareEditingDomain;

import org.eclipse.emf.compare.ide.internal.utils.DisposableResourceSet;

import org.eclipse.emf.compare.ide.internal.utils.NotLoadingResourceSet;

import org.eclipse.emf.compare.ide.ui.internal.EMFCompareIDEUIMessages;

import org.eclipse.emf.compare.ide.ui.internal.EMFCompareIDEUIPlugin;

import org.eclipse.emf.compare.ide.ui.internal.configuration.EMFCompareConfiguration;

import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.MirrorUtil;

import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.label.NoDifferencesCompareInput;

import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.label.NoSelectedItemCompareInput;

import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.label.NoVisibleItemCompareInput;

import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.label.OnlyPseudoConflictsCompareInput;

import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.util.EMFCompareColor;

import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.util.RedoAction;

import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.util.UndoAction;

import org.eclipse.emf.compare.ide.ui.internal.editor.ComparisonScopeInput;

import org.eclipse.emf.compare.ide.ui.internal.logical.ComparisonScopeBuilder;

import org.eclipse.emf.compare.ide.ui.internal.logical.EmptyComparisonScope;

import org.eclipse.emf.compare.ide.ui.internal.logical.StreamAccessorStorage;

import org.eclipse.emf.compare.ide.ui.internal.preferences.EMFCompareUIPreferences;

import org.eclipse.emf.compare.ide.ui.internal.progress.JobProgressInfoComposite;

import org.eclipse.emf.compare.ide.ui.internal.progress.JobProgressMonitorWrapper;

import org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.EMFCompareStructureMergeViewerContentProvider.FetchListener;

import org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions.MergeAction;

import org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions.MergeContainedNonConflictingAction;

import org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.provider.TreeCompareInputAdapterFactory;

import org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.provider.TreeNodeCompareInput;

import org.eclipse.emf.compare.ide.ui.internal.util.CompareHandlerService;

import org.eclipse.emf.compare.ide.ui.internal.util.JFaceUtil;

import org.eclipse.emf.compare.ide.ui.internal.util.PlatformElementUtil;

import org.eclipse.emf.compare.internal.merge.MergeDataImpl;

import org.eclipse.emf.compare.internal.merge.MergeMode;

import org.eclipse.emf.compare.merge.AbstractMerger;

import org.eclipse.emf.compare.merge.CachingDiffRelationshipComputer;

import org.eclipse.emf.compare.merge.IMergeOptionAware;

import org.eclipse.emf.compare.merge.IMerger;

import org.eclipse.emf.compare.rcp.EMFCompareRCPPlugin;

import org.eclipse.emf.compare.rcp.internal.extension.impl.EMFCompareBuilderConfigurator;

import org.eclipse.emf.compare.rcp.ui.internal.configuration.ICompareEditingDomainChange;

import org.eclipse.emf.compare.rcp.ui.internal.configuration.IMergePreviewModeChange;

import org.eclipse.emf.compare.rcp.ui.internal.configuration.SideLabelProvider;

import org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.IColorChangeEvent;

import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.StructureMergeViewerFilter;

import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.impl.CascadingDifferencesFilter;

import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.StructureMergeViewerGrouper;

import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.provider.TreeItemProviderAdapterFactorySpec;

import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.match.MatchOfContainmentReferenceChangeProcessor;

import org.eclipse.emf.compare.rcp.ui.internal.util.SWTUtil;

import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.filters.IDifferenceFilterChange;

import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.groups.IDifferenceGroup;

import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.groups.IDifferenceGroupProvider;

import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.groups.IDifferenceGroupProviderChange;

import org.eclipse.emf.compare.scope.IComparisonScope;

import org.eclipse.emf.compare.utils.EMFComparePredicates;

import org.eclipse.emf.compare.utils.IDiagnosable;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.emf.ecore.resource.ResourceSet;

import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.emf.edit.provider.ComposedAdapterFactory;

import org.eclipse.emf.edit.provider.IDisposable;

import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;

import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory;

import org.eclipse.emf.edit.tree.TreeFactory;

import org.eclipse.emf.edit.tree.TreeNode;

import org.eclipse.jface.action.IMenuListener;

import org.eclipse.jface.action.IMenuManager;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.util.IPropertyChangeListener;

import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.jface.viewers.AbstractTreeViewer;

import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.ITreeViewerListener;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeExpansionEvent;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.CTabFolder;

import org.eclipse.swt.custom.CTabItem;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.DisposeEvent;

import org.eclipse.swt.events.FocusAdapter;

import org.eclipse.swt.events.FocusEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Tree;

import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.team.internal.ui.mapping.ResourceDiffCompareInput;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.actions.ActionFactory;

import org.eclipse.ui.progress.PendingUpdateAdapter;

import org.eclipse.ui.themes.ITheme;

import org.eclipse.ui.themes.IThemeManager;

192

193 /**

194 * Implementation of {@link AbstractStructuredViewerWrapper}.

195 *

196 * @author <a href="mailto:axel.richard@obeo.fr">Axel Richard</a>

197 */

public class EMFCompareStructureMergeViewer extends AbstractStructuredViewerWrapper<CTabFolder, WrappableTreeViewer> implements CommandStackListener {

199

200 private final class CompareInputChangedJob extends Job {

201 private CompareInputChangedJob(String name) {

202 super(name);

203 }

204

205 @Override

206 public IStatus run(IProgressMonitor monitor) {

                        IProgressMonitor wrapper = new JobProgressMonitorWrapper(monitor, progressInfoItem);

                        SubMonitor subMonitor = SubMonitor.convert(wrapper, EMFCompareIDEUIMessages

                                        .getString("EMFCompareStructureMergeViewer.computingModelDifferences"), 100); //$NON-NLS-1$

210 try {

                                compareInputChanged((ICompareInput)getInput(), subMonitor.newChild(100));

                        } catch (final OperationCanceledException e) {

213 return Status.CANCEL_STATUS;

                        } catch (final Exception e) {

                                EMFCompareIDEUIPlugin.getDefault().log(e);

216 } finally {

                                subMonitor.setWorkRemaining(0);

218 }

219 return Status.OK_STATUS;

220 }

221 }

222

223 private final class TitleBuilderJob extends Job {

224

225 public TitleBuilderJob() {

                        super("EMF Compare Title Builder"); //$NON-NLS-1$

227 setSystem(true);

228 }

229

230 @Override

231 protected IStatus run(IProgressMonitor monitor) {

                        final String title = new TitleBuilder(getCompareConfiguration()).toString();

                        getContentProvider().runWhenReady(IN_UI_ASYNC, new Runnable() {

234 public void run() {

235 CTabFolder control = getControl();

                                        if (!control.isDisposed()) {

                                                ((CompareViewerSwitchingPane)control.getParent()).setTitleArgument(title);

238 }

239 }

240 });

241 return Status.OK_STATUS;

242 }

243 }

244

245 /** The width of the tree ruler. */

246 private static final int TREE_RULER_WIDTH = 17;

247

        private static final Function<TreeNode, Diff> TREE_NODE_AS_DIFF = new Function<TreeNode, Diff>() {

249 public Diff apply(TreeNode input) {

                        if (input.getData() instanceof Diff) {

                                return (Diff)input.getData();

252 }

253 return null;

254 }

255 };

256

257 /** Preference store holding UI-related settings for this viewer. */

        protected final IPreferenceStore preferenceStore = EMFCompareIDEUIPlugin.getDefault()

259 .getPreferenceStore();

260

261 /** The adapter factory. */

262 private ComposedAdapterFactory fAdapterFactory;

263

264 /** The diff relationship computer. */

265 private CachingDiffRelationshipComputer fDiffRelationshipComputer;

266

267 /** The tree ruler associated with this viewer. */

268 private EMFCompareDiffTreeRuler treeRuler;

269

270 private final ICompareInputChangeListener fCompareInputChangeListener;

271

272 /** The expand/collapse item listener. */

273 private ITreeViewerListener fWrappedTreeListener;

274

275 /** The tree viewer. */

276

277 /** The undo action. */

278 private UndoAction undoAction;

279

280 /** The redo action. */

281 private RedoAction redoAction;

282

283 /** The compare handler service. */

284 private CompareHandlerService fHandlerService;

285

286 /**

287 * When comparing EObjects from a resource, the resource involved doesn't need to be unload by EMF

288 * Compare.

289 */

290 private boolean resourceSetShouldBeDisposed;

291

292 private DependencyData dependencyData;

293

294 private ISelectionChangedListener selectionChangeListener;

295

296 /** The current selection. */

297 protected ISelection currentSelection;

298

299 /** Listener reacting to changes in the {@link #preferenceStore}. */

300 protected IPropertyChangeListener preferenceChangeListener;

301

302 private final Listener fEraseItemListener;

303

304 private JobProgressInfoComposite progressInfoItem;

305

306 private Job inputChangedTask;

307

        private final Job titleBuilderJob = new TitleBuilderJob();

309

310 private CompareToolBar toolBar;

311

312 private Navigatable navigatable;

313

314 private EMFCompareColor fColors;

315

316 private boolean editingDomainNeedsToBeDisposed;

317

318 private FetchListener toolbarUpdaterContentProviderListener;

319

320 private boolean cascadingDifferencesFilterEnabled;

321

322 private IPropertyChangeListener fPreferenceChangeListener;

323

324 private IPreferenceStore fPreferenceStore;

325

326 /**

327 * Constructor.

328 *

329 * @param parent

330 * the SWT parent control under which to create the viewer's SWT control.

331 * @param config

332 * a compare configuration the newly created viewer might want to use.

333 */

        public EMFCompareStructureMergeViewer(Composite parent, EMFCompareConfiguration config) {

335 super(parent, config);

336

                updateLayout(true, false);

338

339 StructureMergeViewerFilter structureMergeViewerFilter = getCompareConfiguration()

340 .getStructureMergeViewerFilter();

                getViewer().addFilter(structureMergeViewerFilter);

342

343 StructureMergeViewerGrouper structureMergeViewerGrouper = getCompareConfiguration()

344 .getStructureMergeViewerGrouper();

                structureMergeViewerGrouper.install(getViewer());

346

347 fCompareInputChangeListener = new ICompareInputChangeListener() {

348 public void compareInputChanged(ICompareInput input) {

                                EMFCompareStructureMergeViewer.this.compareInputChanged(input);

350 }

351 };

352

                setContentProvider(new EMFCompareStructureMergeViewerContentProvider(

                                getCompareConfiguration().getAdapterFactory(), getViewer()));

355

                navigatable = new Navigatable(getViewer(), getContentProvider());

357

                toolBar = new CompareToolBar(CompareViewerPane.getToolBarManager(parent), structureMergeViewerGrouper,

359 structureMergeViewerFilter, getCompareConfiguration());

                getViewer().addSelectionChangedListener(toolBar);

361

362 createContextMenu();

363

364 selectionChangeListener = new ISelectionChangedListener() {

365 public void selectionChanged(SelectionChangedEvent event) {

366 handleSelectionChangedEvent(event);

367 }

368 };

369 addSelectionChangedListener(selectionChangeListener);

370

371 preferenceChangeListener = new IPropertyChangeListener() {

372 public void propertyChange(PropertyChangeEvent event) {

                                EMFCompareStructureMergeViewer.this.handlePreferenceChangedEvent(event);

374 }

375 };

376 preferenceStore.addPropertyChangeListener(preferenceChangeListener);

377

378 fWrappedTreeListener = new ITreeViewerListener() {

379 public void treeExpanded(TreeExpansionEvent event) {

380 treeRuler.redraw();

381 }

382

383 public void treeCollapsed(TreeExpansionEvent event) {

384 treeRuler.redraw();

385 }

386 };

                getViewer().addTreeListener(fWrappedTreeListener);

388

389 fEraseItemListener = new Listener() {

390 public void handleEvent(Event event) {

391 handleEraseItemEvent(event);

392 }

393 };

                getViewer().getControl().addListener(SWT.EraseItem, fEraseItemListener);

395

                fHandlerService = CompareHandlerService.createFor(getCompareConfiguration().getContainer(),

397 getControl().getShell());

398

399 toolbarUpdaterContentProviderListener = new FetchListener() {

400

401 @Override

402 public void startFetching() {

                                toolBar.setEnabled(false);

404 }

405

406 @Override

407 public void doneFetching() {

                                toolBar.setEnabled(true);

409 }

410 };

411

                getContentProvider().addFetchingListener(toolbarUpdaterContentProviderListener);

413

414 setLabelProvider(

                                new DelegatingStyledCellLabelProvider(new EMFCompareStructureMergeViewerLabelProvider(

                                                getCompareConfiguration().getAdapterFactory(), this)));

417

                undoAction = new UndoAction(getCompareConfiguration().getEditingDomain());

                redoAction = new RedoAction(getCompareConfiguration().getEditingDomain());

420

                editingDomainChange(null, getCompareConfiguration().getEditingDomain());

422

                inputChangedTask.setPriority(Job.LONG);

424

                config.getEventBus().register(this);

426

                final boolean enabled = any(config.getStructureMergeViewerFilter().getSelectedDifferenceFilters(),

                                instanceOf(CascadingDifferencesFilter.class));

429 setCascadingDifferencesFilterEnabled(enabled);

430

431 fPreferenceChangeListener = new IPropertyChangeListener() {

432 @Override

433 public void propertyChange(PropertyChangeEvent event) {

                                EMFCompareStructureMergeViewer.this.handlePreferenceChangeEvent(event);

435 }

436 };

437

                fPreferenceStore = getCompareConfiguration().getPreferenceStore();

                if (fPreferenceStore != null) {

440 fPreferenceStore.addPropertyChangeListener(fPreferenceChangeListener);

441 }

442 }

443

444 protected void handlePreferenceChangeEvent(PropertyChangeEvent event) {

                if (MirrorUtil.isMirroredPreference(event.getProperty())) {

                        MirrorUtil.setMirrored(getCompareConfiguration(),

                                        Boolean.parseBoolean(event.getNewValue().toString()));

448 // Since the content merge viewer will only be recreated, we simulate a selection change to

449 // re-create the content merge viewer with correct sides

450 ISelection originalSelection = getSelection();

451

452 setSelection(null);

                        getViewer().handleOpen(null); // parameter not used in super implementation -> null ok

454

455 setSelection(originalSelection);

                        getViewer().handleOpen(null);

457 }

458 }

459

460 /**

461 * The tool bar must be init after we know the editable state of left and right input.

462 *

463 * @see #compareInputChanged(ICompareInput, IProgressMonitor)

464 */

465 private void initToolbar(IProgressMonitor monitor) {

                if (!monitor.isCanceled()) {

                        SWTUtil.safeSyncExec(new Runnable() {

468 public void run() {

                                        toolBar.initToolbar(getViewer(), navigatable);

                                        toolBar.setEnabled(false);

471 }

472 });

473 }

474 }

475

476 private void enableToolbar(IProgressMonitor monitor) {

                if (!monitor.isCanceled()) {

                        SWTUtil.safeSyncExec(new Runnable() {

479 public void run() {

                                        toolBar.setEnabled(true);

481 }

482 });

483 }

484 }

485

486 /**

487 * Allow users to merge diffs through context menu.

488 */

489 private void createContextMenu() {

                MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$

                menuMgr.setRemoveAllWhenShown(true);

                menuMgr.addMenuListener(new IMenuListener() {

493 public void menuAboutToShow(IMenuManager manager) {

                                EMFCompareStructureMergeViewer.this.fillContextMenu(manager);

495 }

496 });

                Menu menu = menuMgr.createContextMenu(getViewer().getControl());

                getViewer().getControl().setMenu(menu);

499 }

500

501 /**

502 * Fill the context menu with the appropriate actions (ACCEPT/REJECT or LEFT TO RIGHT/RIGHT TO LEFT

503 * depending on the {@link org.eclipse.emf.compare.internal.merge.MergeMode}, and the write access of

504 * models in input).

505 *

506 * @param manager

507 * the context menu to fill.

508 */

509 private void fillContextMenu(IMenuManager manager) {

510 if (!isOneMergeableItemSelected()) {

511 return;

512 }

                boolean leftEditable = getCompareConfiguration().isLeftEditable();

                boolean rightEditable = getCompareConfiguration().isRightEditable();

515 final EnumSet<MergeMode> modes;

516 if (rightEditable && leftEditable) {

                        modes = EnumSet.of(MergeMode.RIGHT_TO_LEFT, MergeMode.LEFT_TO_RIGHT);

518 } else {

                        modes = EnumSet.of(MergeMode.ACCEPT, MergeMode.REJECT);

520 }

521 if (rightEditable || leftEditable) {

522 for (MergeMode mode : modes) {

                                IMerger.Registry mergerRegistry = EMFCompareRCPPlugin.getDefault().getMergerRegistry();

524 if (isOneDiffSelected()) {

                                        MergeAction mergeAction = new MergeAction(getCompareConfiguration(), mergerRegistry, mode,

526 navigatable, (IStructuredSelection)getSelection());

527 manager.add(mergeAction);

                                } else if (isOneMatchOrResourceMatchSelected()) {

                                        final Predicate<TreeNode> filterPredicate = new Predicate<TreeNode>() {

530 public boolean apply(TreeNode input) {

531 return input != null

                                                                        && JFaceUtil.isFiltered(getViewer(), input, input.getParent());

533 }

534 };

535 MergeContainedNonConflictingAction mergeAction = new MergeContainedNonConflictingAction(

                                                        getCompareConfiguration(), mergerRegistry, mode, navigatable,

                                                        (IStructuredSelection)getSelection(), filterPredicate);

538 manager.add(mergeAction);

539 }

540 }

541 }

542 }

543

544 /**

545 * Check if the item selected in this viewer is mergeable; that is, if a {@link Diff}, a {@link Match}, or

546 * {@link MatchResource} is selected.

547 *

548 * @return true if the item selected is mergeable, false otherwise.

549 */

550 private boolean isOneMergeableItemSelected() {

                return isOneDiffSelected() || isOneMatchOrResourceMatchSelected();

552 }

553

554 /**

555 * Specifies whether the a {@link Match} or a {@link MatchResource} is currently selected in this viewer.

556 *

557 * @return <code>true</code> if an instance of a {@link Match} or a {@link MatchResource} is selected,

558 * <code>false</code> otherwise.

559 */

560 private boolean isOneDiffSelected() {

561 final ISelection selection = getSelection();

                if (selection instanceof IStructuredSelection && ((IStructuredSelection)selection).size() == 1) {

                        Object element = ((IStructuredSelection)selection).getFirstElement();

                        if (getDataOfTreeNodeOfAdapter(element) instanceof Diff) {

565 return true;

566 }

567 }

568 return false;

569 }

570

571 /**

572 * Specifies whether the a {@link Match} or a {@link MatchResource} is currently selected in this viewer.

573 *

574 * @return <code>true</code> if an instance of a {@link Match} or a {@link MatchResource} is selected,

575 * <code>false</code> otherwise.

576 */

577 private boolean isOneMatchOrResourceMatchSelected() {

578 final ISelection selection = getSelection();

                if (selection instanceof IStructuredSelection && ((IStructuredSelection)selection).size() == 1) {

                        Object element = ((IStructuredSelection)selection).getFirstElement();

                        if (isMatchOrMatchResource(getDataOfTreeNodeOfAdapter(element))) {

582 return true;

583 }

584 }

585 return false;

586 }

587

588 /**

589 * Specifies whether the given {@code eObject} is a {@link Match} or a {@link MatchResource}.

590 *

591 * @param eObject

592 * The EObject to check.

593 * @return <code>true</code> if it is an instance a {@link Match} or a {@link MatchResource},

594 * <code>false</code> otherwise.

595 */

596 private boolean isMatchOrMatchResource(EObject eObject) {

                return eObject instanceof Match || eObject instanceof MatchResource;

598 }

599

600 /**

601 * {@inheritDoc}

602 *

603 * @see org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.AbstractViewerWrapper#preHookCreateControlAndViewer()

604 */

605 @Override

606 protected void preHookCreateControlAndViewer() {

                fAdapterFactory = initAdapterFactory(getCompareConfiguration().getComparison());

                getCompareConfiguration().setAdapterFactory(fAdapterFactory);

609

610 fDiffRelationshipComputer = new CachingDiffRelationshipComputer(

                                EMFCompareRCPPlugin.getDefault().getMergerRegistry());

                getCompareConfiguration().setDiffRelationshipComputer(fDiffRelationshipComputer);

613

614 inputChangedTask = new CompareInputChangedJob(EMFCompareIDEUIMessages

                                .getString("EMFCompareStructureMergeViewer.computingModelDifferences")); //$NON-NLS-1$

616 }

617

618 /**

619 * Creates a new adapter factory based on the current compare configuration.

620 *

621 * @return adapter factory

622 */

623 protected ComposedAdapterFactory initAdapterFactory(Comparison comparison) {

                Map<Object, Object> context = Maps.newLinkedHashMap();

                context.put(IContextTester.CTX_COMPARISON, comparison);

626

627 ComposedAdapterFactory adapterFactory = new ComposedAdapterFactory(

                                EMFCompareRCPPlugin.getDefault().createFilteredAdapterFactoryRegistry(context));

                adapterFactory.addAdapterFactory(new TreeItemProviderAdapterFactorySpec(

630 getCompareConfiguration().getStructureMergeViewerFilter()));

                adapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());

                adapterFactory.addAdapterFactory(new ResourceItemProviderAdapterFactory());

633 return adapterFactory;

634 }

635

636 @Subscribe

637 public void colorChanged(

                        @SuppressWarnings("unused") /* necessary for @Subscribe */IColorChangeEvent changeColorEvent) {

639 internalRedraw();

640 }

641

642 /**

643 * {@inheritDoc}

644 *

645 * @see org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.ViewerWrapper.createControl(

646 * Composite, CompareConfiguration)

647 */

648 @Override

        protected ControlAndViewer<CTabFolder, WrappableTreeViewer> createControlAndViewer(Composite parent) {

                parent.setLayout(new FillLayout());

                CTabFolder tabFolder = new CTabFolder(parent, SWT.BOTTOM | SWT.FLAT);

                tabFolder.setLayout(new FillLayout());

653

654 // Ensures that this viewer will only display the page's tab

655 // area if there are more than one page

656 //

                tabFolder.addControlListener(new ControlAdapter() {

658 boolean guard = false;

659

660 @Override

661 public void controlResized(ControlEvent event) {

662 if (!guard) {

663 guard = true;

664 hideTabs();

665 guard = false;

666 }

667 }

668 });

669

670 updateProblemIndication(Diagnostic.OK_INSTANCE);

671

                Composite control = new Composite(tabFolder, SWT.NONE);

                createItem(0, control);

                tabFolder.setSelection(0);

675

                GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);

677 control.setLayoutData(data);

678

                GridLayout layout = new GridLayout(2, false);

680 layout.marginWidth = 0;

681 layout.marginHeight = 0;

682 layout.horizontalSpacing = 0;

683 layout.verticalSpacing = 0;

684 control.setLayout(layout);

685

                progressInfoItem = new JobProgressInfoComposite(inputChangedTask, control,

                                SWT.SMOOTH | SWT.HORIZONTAL, SWT.NONE);

                progressInfoItem.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));

                progressInfoItem.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_LIST_BACKGROUND));

690

                final WrappableTreeViewer treeViewer = new WrappableTreeViewer(control,

                                SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL) {

693 /**

694 * {@inheritDoc}

695 *

696 * @see org.eclipse.jface.viewers.TreeViewer#isExpandable(java.lang.Object)

697 */

698 @Override

699 public boolean isExpandable(Object element) {

700 if (element instanceof PendingUpdateAdapter) {

701 // Prevents requesting the content provider if the object is a PendingUpdateAdapter

702 return false;

703 }

704 if (hasFilters()) {

705 // workaround for 65762

                                        return getFilteredChildren(element).length > 0;

707 }

                                return super.isExpandable(element);

709 }

710 };

                treeViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

                treeViewer.setUseHashlookup(true);

713

                treeViewer.getControl().addFocusListener(new FocusAdapter() {

715 @Override

716 public void focusGained(FocusEvent e) {

                                fHandlerService.updatePaneActionHandlers(new Runnable() {

718 public void run() {

                                                fHandlerService.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);

                                                fHandlerService.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);

721 }

722 });

723 }

724 });

725

                dependencyData = new DependencyData(getCompareConfiguration());

727

                tabFolder.setData(CompareUI.COMPARE_VIEWER_TITLE,

                                EMFCompareIDEUIMessages.getString("EMFCompareStructureMergeViewer.title")); //$NON-NLS-1$

730

731 final ITheme currentTheme = getCurrentTheme();

732

                boolean leftIsLocal = getCompareConfiguration().getBooleanProperty("LEFT_IS_LOCAL", false); //$NON-NLS-1$

                fColors = new EMFCompareColor(control.getDisplay(), leftIsLocal, currentTheme,

735 getCompareConfiguration().getEventBus());

736

                treeRuler = new EMFCompareDiffTreeRuler(control, SWT.NONE, treeViewer, dependencyData, fColors);

                GridData rulerLayoutData = new GridData(SWT.FILL, SWT.FILL, false, true);

739 rulerLayoutData.exclude = true;

740 rulerLayoutData.widthHint = TREE_RULER_WIDTH;

741 rulerLayoutData.minimumWidth = TREE_RULER_WIDTH;

742 treeRuler.setLayoutData(rulerLayoutData);

743

                return ControlAndViewer.create(tabFolder, treeViewer);

745 }

746

747 /**

748 * Determines the current used theme.

749 *

750 * @return The currently used theme if available, {@code null} otherwise.

751 */

752 private ITheme getCurrentTheme() {

                if (PlatformUI.isWorkbenchRunning()) {

                        final IThemeManager themeManager = PlatformUI.getWorkbench().getThemeManager();

                        if (themeManager != null) {

756 return themeManager.getCurrentTheme();

757 }

758 }

759 return null;

760 }

761

762 /**

763 * {@inheritDoc}

764 *

765 * @see org.eclipse.jface.viewers.ContentViewer#getContentProvider()

766 */

767 @Override

768 public EMFCompareStructureMergeViewerContentProvider getContentProvider() {

                return (EMFCompareStructureMergeViewerContentProvider)super.getContentProvider();

770 }

771

772 @Override

773 public DelegatingStyledCellLabelProvider getLabelProvider() {

                return (DelegatingStyledCellLabelProvider)super.getLabelProvider();

775 }

776

        private CTabItem createItem(int index, Control control) {

                CTabItem item = new CTabItem((CTabFolder)control.getParent(), SWT.NONE, index);

779 item.setControl(control);

780 return item;

781 }

782

783 @Subscribe

784 public void handleEditingDomainChange(ICompareEditingDomainChange event) {

                editingDomainChange(event.getOldValue(), event.getNewValue());

786 }

787

        private void editingDomainChange(ICompareEditingDomain oldValue, ICompareEditingDomain newValue) {

789 if (newValue != oldValue) {

                        if (oldValue != null) {

                                oldValue.getCommandStack().removeCommandStackListener(this);

792 }

793

                        if (newValue != null) {

                                newValue.getCommandStack().addCommandStackListener(this);

796 }

797

798 undoAction.setEditingDomain(newValue);

799 redoAction.setEditingDomain(newValue);

800 }

801 }

802

803 private void refreshTitle() {

                if (getControl().isDisposed() || !(getControl().getParent() instanceof CompareViewerSwitchingPane)) {

805 return;

806 }

807

                if (getCompareConfiguration().getComparison() == null) {

809 return;

810 }

811

812 // Schedule with a short delay, because refreshTitle is often called multiple times quickly and this

813 // way, with a short delay, the job is run only once even in that case.

                titleBuilderJob.schedule(10L);

815 }

816

817 static EObject getDataOfTreeNodeOfAdapter(Object object) {

818 EObject data = null;

819 if (object instanceof Adapter) {

                        Notifier target = ((Adapter)object).getTarget();

821 if (target instanceof TreeNode) {

                                data = ((TreeNode)target).getData();

823 }

824 }

825 return data;

826 }

827

828 @Subscribe

        public void mergePreviewModeChange(@SuppressWarnings("unused") IMergePreviewModeChange event) {

                SWTUtil.safeAsyncExec(new Runnable() {

831 public void run() {

832 updateHighlightRelatedChanges(getSelection());

833 }

834 });

835 }

836

837 @Subscribe

838 public void handleDifferenceFilterChange(IDifferenceFilterChange event) {

                final boolean enabled = any(event.getSelectedDifferenceFilters(),

                                instanceOf(CascadingDifferencesFilter.class));

841 setCascadingDifferencesFilterEnabled(enabled);

                SWTUtil.safeRefresh(this, false, true);

                getContentProvider().runWhenReady(IN_UI_ASYNC, new Runnable() {

844 public void run() {

                                if (navigatable != null && (navigatable.getViewer().getSelection() == null

                                                || navigatable.getViewer().getSelection().isEmpty())) {

                                        selectFirstDiffOrDisplayLabelViewer(getCompareConfiguration().getComparison());

848 }

849 }

850 });

851 }

852

853 /**

854 * Set the state of the cascading filter.

855 *

856 * @param enable

857 * true if the filter is enabled, false otherwise.

858 */

        private void setCascadingDifferencesFilterEnabled(boolean enable) {

860 this.cascadingDifferencesFilterEnabled = enable;

                IMerger.Registry mergerRegistry = EMFCompareRCPPlugin.getDefault().getMergerRegistry();

                for (IMergeOptionAware merger : Iterables.filter(mergerRegistry.getMergers(null),

863 IMergeOptionAware.class)) {

                        Map<Object, Object> mergeOptions = merger.getMergeOptions();

                        mergeOptions.put(AbstractMerger.SUB_DIFF_AWARE_OPTION, Boolean.valueOf(enable));

866 }

867 }

868

869 /**

870 * Get the state of the cascading filter.

871 *

872 * @return true if the filter is enabled, false otherwise.

873 */

874 private boolean getCascadingDifferencesFilterEnabled() {

875 return this.cascadingDifferencesFilterEnabled;

876 }

877

878 @Subscribe

879 public void handleDifferenceGroupProviderChange(

                        @SuppressWarnings("unused") IDifferenceGroupProviderChange event) {

                SWTUtil.safeRefresh(this, false, true);

                getContentProvider().runWhenReady(IN_UI_ASYNC, new Runnable() {

883 public void run() {

                                selectFirstDiffOrDisplayLabelViewer(getCompareConfiguration().getComparison());

885 }

886 });

887 }

888

889 /**

890 * {@inheritDoc}

891 *

892 * @see org.eclipse.jface.viewers.Viewer#inputChanged(Object, Object)

893 */

894 @Override

        protected void inputChanged(Object input, Object oldInput) {

896 if (oldInput instanceof ICompareInput) {

897 ICompareInput old = (ICompareInput)oldInput;

898 old.removeCompareInputChangeListener(fCompareInputChangeListener);

899 toolBar.dispose();

900 }

901 if (input instanceof ICompareInput) {

902 ICompareInput ci = (ICompareInput)input;

903 ci.addCompareInputChangeListener(fCompareInputChangeListener);

904 compareInputChanged(ci);

905 }

906 }

907

908 /**

909 * {@inheritDoc}

910 *

911 * @see org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.AbstractViewerWrapper#handleDispose(DisposeEvent)

912 */

913 @Override

914 protected void handleDispose(DisposeEvent event) {

                if (fHandlerService != null) {

916 fHandlerService.dispose();

917 }

                getCompareConfiguration().getEventBus().unregister(this);

                getViewer().removeTreeListener(fWrappedTreeListener);

920 Object input = getInput();

921 if (input instanceof ICompareInput) {

922 ICompareInput ci = (ICompareInput)input;

923 ci.removeCompareInputChangeListener(fCompareInputChangeListener);

924 }

925 removeSelectionChangedListener(selectionChangeListener);

                getViewer().removeSelectionChangedListener(toolBar);

                getViewer().getTree().removeListener(SWT.EraseItem, fEraseItemListener);

                if (preferenceChangeListener != null) {

929 preferenceStore.removePropertyChangeListener(preferenceChangeListener);

930 }

931 if (editingDomainNeedsToBeDisposed) {

                        ((IDisposable)getCompareConfiguration().getEditingDomain()).dispose();

933 }

                getCompareConfiguration().getStructureMergeViewerGrouper().uninstall(getViewer());

                compareInputChanged((ICompareInput)null);

936 treeRuler.handleDispose();

937 fAdapterFactory.dispose();

938 fDiffRelationshipComputer.invalidate();

939 toolBar.dispose();

940 fColors.dispose();

941

                if (fPreferenceChangeListener != null) {

                        if (fPreferenceStore != null) {

944 fPreferenceStore.removePropertyChangeListener(fPreferenceChangeListener);

945 }

946 fPreferenceChangeListener = null;

947 }

                super.handleDispose(event);

949 }

950

951 /**

952 * {@inheritDoc}

953 *

954 * @see org.eclipse.emf.common.command.CommandStackListener#commandStackChanged(java.util.EventObject)

955 */

956 public void commandStackChanged(EventObject event) {

957 undoAction.update();

958 redoAction.update();

959

                Command mostRecentCommand = ((CommandStack)event.getSource()).getMostRecentCommand();

961 if (mostRecentCommand instanceof ICompareCopyCommand) {

962 // MUST NOT call a setSelection with a list, o.e.compare does not handle it (cf

963 // org.eclipse.compare.CompareEditorInput#getElement(ISelection))

                        Collection<?> affectedObjects = mostRecentCommand.getAffectedObjects();

965 TreeNode unfilteredNode = null;

                        if (!affectedObjects.isEmpty()) {

                                final Iterator<EObject> affectedIterator = Iterables.filter(affectedObjects, EObject.class)

968 .iterator();

969 IDifferenceGroupProvider groupProvider = getCompareConfiguration()

                                                .getStructureMergeViewerGrouper().getProvider();

                                while (affectedIterator.hasNext() && unfilteredNode == null) {

972 EObject affected = affectedIterator.next();

                                        Iterable<TreeNode> treeNodes = groupProvider.getTreeNodes(affected);

974 for (TreeNode node : treeNodes) {

                                                if (!JFaceUtil.isFiltered(getViewer(), node, node.getParent())) {

976 unfilteredNode = node;

977 break;

978 }

979 }

980 }

981 }

                        if (unfilteredNode != null) {

                                final Object adaptedAffectedObject = fAdapterFactory.adapt(unfilteredNode,

984 ICompareInput.class);

985 // be sure the affected object has been created in the viewer.

                                for (TreeNode node : getPath(null, unfilteredNode)) {

                                        getViewer().expandToLevel(fAdapterFactory.adapt(node, ICompareInput.class), 0);

988 }

989 // execute synchronously the set selection to be sure the MergeAction#run() will

990 // select next diff after.

                                SWTUtil.safeSyncExec(new Runnable() {

992 public void run() {

993 refresh();

                                                StructuredSelection selection = new StructuredSelection(adaptedAffectedObject);

995 // allows to call CompareToolBar#selectionChanged(SelectionChangedEvent)

                                                getViewer().setSelection(selection);

997 }

998 });

999 // update content viewers with the new selection

                                SWTUtil.safeAsyncExec(new Runnable() {

1001 public void run() {

1002 navigatable.openSelectedChange();

1003 }

1004 });

1005 }

1006 } else {

1007 // FIXME, should recompute the difference, something happened outside of this compare editor

1008 }

1009

1010 }

1011

        private Iterable<TreeNode> getPath(TreeNode from, TreeNode to) {

1013 if (to == from) {

1014 return Collections.emptyList();

1015 }

1016

                final List<TreeNode> path = new ArrayList<TreeNode>();

1018 path.add(to);

1019 TreeNode parent = to.getParent();

                while (parent != null && parent != from) {

1021 path.add(parent);

1022 parent = parent.getParent();

1023 }

                return Lists.reverse(path);

1025 }

1026

1027 /**

1028 * Triggered by fCompareInputChangeListener and {@link #inputChanged(Object, Object)}.

1029 */

1030 void compareInputChanged(ICompareInput input) {

                if (input == null) {

1032 // When closing, we don't need a progress monitor to handle the input change

                        compareInputChanged((ICompareInput)null, new NullProgressMonitor());

1034 return;

1035 }

1036 // The compare configuration is nulled when the viewer is disposed

                if (getCompareConfiguration() != null) {

                        updateLayout(true, true);

1039 inputChangedTask.schedule();

1040 }

1041 }

1042

        void compareInputChanged(CompareInputAdapter input, IProgressMonitor monitor) {

                compareInputChanged(null, (Comparison)input.getComparisonObject(), monitor);

1045 }

1046

        void compareInputChanged(ComparisonScopeInput input, IProgressMonitor monitor) {

                if (monitor.isCanceled()) {

1049 return;

1050 }

1051 IComparisonScope comparisonScope = input.getComparisonScope();

1052 EMFCompareConfiguration compareConfiguration = getCompareConfiguration();

1053

1054 EMFCompare comparator = compareConfiguration.getEMFComparator();

                compareConfiguration.setLeftEditable(input.isLeftEditable());

                compareConfiguration.setRightEditable(input.isRightEditable());

1057

                if (input.isLeftEditable() && input.isRightEditable()) {

                        compareConfiguration.setMergePreviewMode(MergeMode.RIGHT_TO_LEFT);

1060 } else {

                        compareConfiguration.setMergePreviewMode(MergeMode.ACCEPT);

1062 }

1063

1064 // setup defaults

                if (compareConfiguration.getEditingDomain() == null) {

                        ICompareEditingDomain domain = EMFCompareEditingDomain.create(comparisonScope.getLeft(),

                                        comparisonScope.getRight(), comparisonScope.getOrigin());

1068 compareConfiguration.setEditingDomain(domain);

1069 }

                if (comparator == null) {

1071 Builder builder = EMFCompare.builder();

                        EMFCompareBuilderConfigurator.createDefault().configure(builder);

1073 comparator = builder.build();

1074 }

1075

                SubMonitor subMonitor = SubMonitor.convert(monitor, 10);

                final Comparison comparison = comparator.compare(comparisonScope,

                                BasicMonitor.toMonitor(subMonitor.newChild(10)));

1079

1080 // Bug 458802: NPE when synchronizing SMV & CMV if comparison is empty

1081 hookAdapters(input, comparison);

1082

                compareInputChanged(input.getComparisonScope(), comparison, monitor);

1084 }

1085

        void compareInputChanged(final IComparisonScope scope, final Comparison comparison,

1087 final IProgressMonitor monitor) {

                if (!getControl().isDisposed() && !monitor.isCanceled()) { // guard against disposal

1089 final EMFCompareConfiguration config = getCompareConfiguration();

1090

1091 ComposedAdapterFactory oldAdapterFactory = fAdapterFactory;

1092 // re-initialize adapter factory due to new comparison

1093 fAdapterFactory = initAdapterFactory(comparison);

1094

1095 // clear cache for new comparison

                        if (fDiffRelationshipComputer != null) {

1097 fDiffRelationshipComputer.invalidate();

1098 }

1099

1100 // propagate new adapter factory

1101 config.setAdapterFactory(fAdapterFactory);

                        getContentProvider().setAdapterFactory(fAdapterFactory);

                        ((EMFCompareStructureMergeViewerLabelProvider)getLabelProvider().getStyledStringProvider())

1104 .setAdapterFactory(fAdapterFactory);

1105

                        final TreeNode treeNode = TreeFactory.eINSTANCE.createTreeNode();

1107 treeNode.setData(comparison);

                        final Object input = fAdapterFactory.adapt(treeNode, ICompareInput.class);

1109

1110 // this will set to the EMPTY difference group provider, but necessary to avoid NPE while

1111 // setting input.

                        IDifferenceGroupProvider groupProvider = config.getStructureMergeViewerGrouper().getProvider();

                        treeNode.eAdapters().add(groupProvider);

1114

1115 // display problem tabs if any

                        if (!monitor.isCanceled()) {

                                SWTUtil.safeAsyncExec(new Runnable() {

1118 public void run() {

1119 Diagnostic diagnostic = comparison.getDiagnostic();

                                                if (diagnostic == null) {

1121 updateProblemIndication(Diagnostic.OK_INSTANCE);

1122 } else {

1123 updateProblemIndication(diagnostic);

1124 }

1125 }

1126 });

1127 }

1128

1129 // must set the input now in a synchronous mean. It will be used in the #setComparisonAndScope

1130 // afterwards during the initialization of StructureMergeViewerFilter and

1131 // StructureMergeViewerGrouper.

                        if (!monitor.isCanceled()) {

                                SWTUtil.safeSyncExec(new Runnable() {

1134 public void run() {

                                                getViewer().setInput(input);

1136 }

1137 });

1138 }

1139

                        config.setComparisonAndScope(comparison, scope);

1141

                        SWTUtil.safeAsyncExec(new Runnable() {

1143

1144 public void run() {

                                        if (!getControl().isDisposed()) {

                                                updateLayout(false, true);

1147 }

1148 }

1149 });

1150

                        getContentProvider().runWhenReady(IN_UI_ASYNC, new Runnable() {

1152 public void run() {

                                        if (!getControl().isDisposed()) {

1154 // title is not initialized as the comparison was set in the configuration after

1155 // the refresh caused by the initialization of the viewer filters and the group

1156 // providers.

1157 refreshTitle();

1158

1159 // Expands the tree viewer to the default expansion level

1160 expandTreeToLevel(getDefaultTreeExpansionLevel());

1161

1162 // Selects the first difference once the tree has been filled.

1163 selectFirstDiffOrDisplayLabelViewer(comparison);

1164 }

1165 }

1166 });

1167

                        SWTUtil.safeAsyncExec(new Runnable() {

1169 public void run() {

                                        fHandlerService.updatePaneActionHandlers(new Runnable() {

1171 public void run() {

                                                        fHandlerService.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);

                                                        fHandlerService.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);

1174 }

1175 });

1176 }

1177 });

1178

1179 // Disposing this at the start of this method would meet frequent CME

                        if (oldAdapterFactory != null) {

1181 oldAdapterFactory.dispose();

1182 }

1183 }

1184 }

1185

        void compareInputChanged(final ICompareInput input, IProgressMonitor monitor) {

                if (input != null && !monitor.isCanceled()) {

1188 if (input instanceof CompareInputAdapter) {

1189 resourceSetShouldBeDisposed = false;

                                compareInputChanged((CompareInputAdapter)input, monitor);

1191 initToolbar(monitor);

                        } else if (input instanceof ComparisonScopeInput) {

1193 resourceSetShouldBeDisposed = false;

                                compareInputChanged((ComparisonScopeInput)input, monitor);

1195 initToolbar(monitor);

1196 } else {

1197 resourceSetShouldBeDisposed = true;

                                SubMonitor subMonitor = SubMonitor.convert(monitor, 100);

1199

                                final ITypedElement left = input.getLeft();

                                final ITypedElement right = input.getRight();

                                final ITypedElement origin = input.getAncestor();

1203

1204 final boolean leftEditable;

1205 final boolean rightEditable;

1206

1207 EMFCompareConfiguration compareConfiguration = getCompareConfiguration();

1208 /*

1209 * A resource node means that the left ITypedElement is in the workspace, a DiffNode input

1210 * means the comparison has been launched from a Replace With action.

1211 */

                                if (left instanceof ResourceNode && !(input instanceof DiffNode)) {

                                        ResourceAttributes attributes = ((ResourceNode)left).getResource()

1214 .getResourceAttributes();

                                        leftEditable = attributes != null && !attributes.isReadOnly();

1216 } else {

1217 leftEditable = compareConfiguration.isLeftEditable();

1218 }

1219

1220 if (right instanceof ResourceNode) {

                                        ResourceAttributes attributes = ((ResourceNode)right).getResource()

1222 .getResourceAttributes();

                                        rightEditable = attributes != null && !attributes.isReadOnly();

1224 } else {

1225 rightEditable = compareConfiguration.isRightEditable();

1226 }

1227

1228 compareConfiguration.setLeftEditable(leftEditable);

1229 compareConfiguration.setRightEditable(rightEditable);

1230

1231 if (leftEditable && rightEditable) {

                                        compareConfiguration.setMergePreviewMode(MergeMode.RIGHT_TO_LEFT);

1233 } else {

                                        compareConfiguration.setMergePreviewMode(MergeMode.ACCEPT);

1235 }

1236

                                final BasicDiagnostic diagnostic = new BasicDiagnostic(Diagnostic.OK,

                                                EMFCompareIDEUIPlugin.PLUGIN_ID, 0, null, new Object[0]);

1239 IComparisonScope scope = null;

1240

1241 try {

                                        scope = ComparisonScopeBuilder.create(compareConfiguration.getContainer(), left, right,

                                                        origin, subMonitor.newChild(85));

1244 } catch (OperationCanceledException e) {

1245 scope = new EmptyComparisonScope();

                                        ((BasicDiagnostic)((EmptyComparisonScope)scope).getDiagnostic())

                                                        .merge(new BasicDiagnostic(Diagnostic.CANCEL, EMFCompareIDEUIPlugin.PLUGIN_ID, 0,

1248 EMFCompareIDEUIMessages

                                                                                        .getString("EMFCompareStructureMergeViewer.operationCanceled"), //$NON-NLS-1$

1250 new Object[] {e, }));

1251 } catch (Exception e) {

1252 scope = new EmptyComparisonScope();

                                        ((BasicDiagnostic)((EmptyComparisonScope)scope).getDiagnostic())

                                                        .merge(BasicDiagnostic.toDiagnostic(e));

                                        EMFCompareIDEUIPlugin.getDefault().log(e);

1256 }

1257

                                if (scope instanceof IDiagnosable && ((IDiagnosable)scope).getDiagnostic() != null) {

                                        diagnostic.merge(((IDiagnosable)scope).getDiagnostic());

1260 }

1261

                                final Builder comparisonBuilder = EMFCompare.builder();

1263

                                EMFCompareBuilderConfigurator.createDefault().configure(comparisonBuilder);

1265

                                SubMonitor subMonitorChild = SubMonitor.convert(subMonitor.newChild(15), 10);

                                final Comparison compareResult = comparisonBuilder.build().compare(scope,

1268 BasicMonitor.toMonitor(subMonitorChild));

1269

1270 hookAdapters(input, compareResult);

1271

                                if (compareResult.getDiagnostic() != null) {

                                        diagnostic.merge(compareResult.getDiagnostic());

1274 }

1275 // update diagnostic of the comparison with the global one.

1276 compareResult.setDiagnostic(diagnostic);

1277

                                final ResourceSet leftResourceSet = (ResourceSet)scope.getLeft();

                                final ResourceSet rightResourceSet = (ResourceSet)scope.getRight();

                                final ResourceSet originResourceSet = (ResourceSet)scope.getOrigin();

1281

                                ICompareEditingDomain editingDomain = EMFCompareEditingDomain.create(leftResourceSet,

1283 rightResourceSet, originResourceSet);

1284 editingDomainNeedsToBeDisposed = true;

1285 compareConfiguration.setEditingDomain(editingDomain);

1286

1287 if (leftResourceSet instanceof NotLoadingResourceSet) {

                                        ((NotLoadingResourceSet)leftResourceSet).setAllowResourceLoad(true);

1289 }

1290 if (rightResourceSet instanceof NotLoadingResourceSet) {

                                        ((NotLoadingResourceSet)rightResourceSet).setAllowResourceLoad(true);

1292 }

1293 if (originResourceSet instanceof NotLoadingResourceSet) {

                                        ((NotLoadingResourceSet)originResourceSet).setAllowResourceLoad(true);

1295 }

1296

                                IStorage leftStorage = PlatformElementUtil.findFile(left);

                                if (leftStorage == null) {

                                        leftStorage = StreamAccessorStorage.fromTypedElement(left);

1300 }

1301

1302 initToolbar(monitor);

                                compareInputChanged(scope, compareResult, monitor);

1304 }

1305 // Protect compare actions from over-enthusiast users

1306 enableToolbar(monitor);

1307 } else {

1308 compareInputChangedToNull();

1309 }

1310 }

1311

1312 /**

1313 * Hooks the adapters required for handling UI properly.

1314 *

1315 * @param input

1316 * @param compareResult

1317 */

        private void hookAdapters(final ICompareInput input, final Comparison compareResult) {

                compareResult.eAdapters().add(new ForwardingCompareInputAdapter(input));

1320 // Thanks to

1321 // org.eclipse.team.internal.ui.mapping.ResourceCompareInputChangeNotifier$CompareInputLabelProvider

1322 // who doesn't check a cast in its getAncestorLabel(), getLeftLabel() and getRightLabel() methods,

1323 // we can't allow to add side label provider in case of an input of type ResourceDiffCompareInput.

1324 if (!(input instanceof ResourceDiffCompareInput)) {

                        ICompareInputLabelProvider labelProvider = getCompareConfiguration().getLabelProvider();

                        SideLabelProvider sideLabelProvider = new SideLabelProvider(labelProvider.getAncestorLabel(input),

                                        labelProvider.getLeftLabel(input), labelProvider.getRightLabel(input),

                                        labelProvider.getAncestorImage(input), labelProvider.getLeftImage(input),

1329 labelProvider.getRightImage(input));

                        compareResult.eAdapters().add(sideLabelProvider);

1331 }

1332 // Bug 501569: The cascading filter does not hide merged cascading diffs

                new MatchOfContainmentReferenceChangeProcessor().execute(compareResult);

1334

1335 // Add a MergeData to handle status decorations on Diffs

                MergeDataImpl mergeData = new MergeDataImpl(getCompareConfiguration().isLeftEditable(),

1337 getCompareConfiguration().isRightEditable());

                compareResult.eAdapters().add(mergeData);

1339 }

1340

1341 /**

1342 * Returns whether the first change should be selected automatically after initialization.

1343 *

1344 * @return true if the first change should be selected automatically, false otherwise.

1345 * @see #selectFirstDiffOrDisplayLabelViewer(Comparison)

1346 */

1347 protected boolean isSelectFirstChange() {

                return preferenceStore.getBoolean(EMFCompareUIPreferences.EDITOR_TREE_AUTO_SELECT_FIRST_CHANGE);

1349 }

1350

1351 /**

1352 * Returns the default expansion level for the tree viewer.

1353 *

1354 * @return non-negative level, or {@link AbstractTreeViewer#ALL_LEVELS ALL_LEVELS} to expand all levels of

1355 * the tree

1356 * @see #expandTreeToLevel(int)

1357 */

1358 protected int getDefaultTreeExpansionLevel() {

                return preferenceStore.getInt(EMFCompareUIPreferences.EDITOR_TREE_AUTO_EXPAND_LEVEL);

1360 }

1361

1362 /**

1363 * Expands the {@link #getViewer() tree viewer} to the given level.

1364 *

1365 * @param level

1366 * non-negative level, or {@link AbstractTreeViewer#ALL_LEVELS ALL_LEVELS} to expand all levels

1367 * of the tree

1368 * @see TreeViewer#expandToLevel(int)

1369 */

        protected void expandTreeToLevel(int level) {

                getViewer().expandToLevel(level);

1372 }

1373

1374 /**

1375 * Returns whether we highlight changes related to the current selected change.

1376 *

1377 * @return true if we highlight related changes, false otherwise.

1378 * @see #updateHighlightRelatedChanges(ISelection)

1379 */

1380 protected boolean isHighlightRelatedChanges() {

                return preferenceStore.getBoolean(EMFCompareUIPreferences.EDITOR_TREE_HIGHLIGHT_RELATED_CHANGES);

1382 }

1383

1384 /**

1385 * Updates the highlighting of related changes for the current selection, if it is

1386 * {@link #isHighlightRelatedChanges() enabled}.

1387 *

1388 * @param selection

1389 * selection

1390 */

1391 protected void updateHighlightRelatedChanges(ISelection selection) {

1392 if (!isHighlightRelatedChanges()) {

1393 return;

1394 }

                dependencyData.updateDependencies(selection, EMFCompareRCPPlugin.getDefault().getMergerRegistry());

1396 internalRedraw();

1397 }

1398

1399 /**

1400 * Clears the highlighting of related changes for the current selection.

1401 */

1402 protected void clearHighlightRelatedChanges() {

1403 dependencyData.clearDependencies();

1404 internalRedraw();

1405 }

1406

1407 /**

1408 * Select the first difference...if there are differences, otherwise, display appropriate content viewer

1409 * (no differences or no visible differences)

1410 *

1411 * @param comparison

1412 * the comparison used to know if there are differences.

1413 */

        private void selectFirstDiffOrDisplayLabelViewer(final Comparison comparison) {

                if (comparison != null) {

                        ICompareInput compareInput = (ICompareInput)EcoreUtil.getAdapter(comparison.eAdapters(),

1417 ICompareInput.class);

                        if (compareInput == null) {

                                compareInput = new TreeNodeCompareInput(new TreeCompareInputAdapterFactory());

1420 }

                        List<Diff> differences = comparison.getDifferences();

                        if (differences.isEmpty()) {

                                navigatable.fireOpen(new NoDifferencesCompareInput(compareInput));

                        } else if (!navigatable.hasChange(INavigatable.FIRST_CHANGE)) {

                                if (hasOnlyPseudoConflicts(differences)) {

                                        navigatable.fireOpen(new OnlyPseudoConflictsCompareInput(compareInput));

1427 } else {

                                        navigatable.fireOpen(new NoVisibleItemCompareInput(compareInput));

1429 }

                        } else if (!isSelectFirstChange()) {

                                navigatable.fireOpen(new NoSelectedItemCompareInput(compareInput));

1432 } else {

                                navigatable.selectChange(INavigatable.FIRST_CHANGE);

1434 }

1435 }

1436 }

1437

        private boolean hasOnlyPseudoConflicts(List<Diff> differences) {

                return Iterators.all(differences.iterator(), EMFComparePredicates.hasConflict(ConflictKind.PSEUDO));

1440 }

1441

        private void updateLayout(boolean displayProgress, boolean doLayout) {

                ((GridData)progressInfoItem.getLayoutData()).exclude = !displayProgress;

1444 progressInfoItem.setVisible(displayProgress);

1445

                ((GridData)getViewer().getControl().getLayoutData()).exclude = displayProgress;

                getViewer().getControl().setVisible(!displayProgress);

1448

                ((GridData)treeRuler.getLayoutData()).exclude = displayProgress;

1450 treeRuler.setVisible(!displayProgress);

1451

1452 if (doLayout) {

                        getControl().layout(true, true);

1454 }

1455 }

1456

1457 private void compareInputChangedToNull() {

                if (!inputChangedTask.cancel()) {

1459 try {

1460 inputChangedTask.join();

1461 } catch (InterruptedException e) {

                                Thread.currentThread().interrupt();

1463 Throwables.propagate(e);

1464 }

1465 }

1466

1467 ResourceSet leftResourceSet = null;

1468 ResourceSet rightResourceSet = null;

1469 ResourceSet originResourceSet = null;

1470

                final Comparison comparison = getCompareConfiguration().getComparison();

                if (comparison != null) {

                        Iterator<Match> matchIt = comparison.getMatches().iterator();

                        if (comparison.isThreeWay()) {

                                while (matchIt.hasNext() && (leftResourceSet == null || rightResourceSet == null

1476 || originResourceSet == null)) {

1477 Match match = matchIt.next();

                                        if (leftResourceSet == null) {

                                                leftResourceSet = getResourceSet(match.getLeft());

1480 }

                                        if (rightResourceSet == null) {

                                                rightResourceSet = getResourceSet(match.getRight());

1483 }

                                        if (originResourceSet == null) {

                                                originResourceSet = getResourceSet(match.getOrigin());

1486 }

1487 }

1488 } else {

                                while (matchIt.hasNext() && (leftResourceSet == null || rightResourceSet == null)) {

1490 Match match = matchIt.next();

                                        if (leftResourceSet == null) {

                                                leftResourceSet = getResourceSet(match.getLeft());

1493 }

                                        if (rightResourceSet == null) {

                                                rightResourceSet = getResourceSet(match.getRight());

1496 }

1497 }

1498 }

                        comparison.eAdapters().clear();

1500 }

1501

                editingDomainChange(getCompareConfiguration().getEditingDomain(), null);

1503

1504 if (resourceSetShouldBeDisposed) {

1505 final ResourceSet finalLeftResourceSet = leftResourceSet;

1506 final ResourceSet finalRightResourceSet = rightResourceSet;

1507 final ResourceSet finalOriginResourceSet = originResourceSet;

                        new Job("Resource Disposer") { //$NON-NLS-1$

1509 @Override

1510 protected IStatus run(IProgressMonitor monitor) {

1511 disposeResourceSet(finalLeftResourceSet);

1512 disposeResourceSet(finalRightResourceSet);

1513 disposeResourceSet(finalOriginResourceSet);

1514 return Status.OK_STATUS;

1515 }

1516 }.schedule();

1517 }

1518

                if (getCompareConfiguration() != null) {

1520 getCompareConfiguration().dispose();

1521 }

                getViewer().setInput(null);

1523 }

1524

1525 /**

1526 * Disposes the {@link ResourceSet}.

1527 *

1528 * @param resourceSet

1529 * that need to be disposed.

1530 */

1531 protected void disposeResourceSet(ResourceSet resourceSet) {

1532 if (resourceSet instanceof DisposableResourceSet) {

                        ((DisposableResourceSet)resourceSet).dispose();

1534 } else {

1535 unload(resourceSet);

1536 }

1537 }

1538

1539 /**

1540 * Handle the erase item event. When select a difference in the structure merge viewer, highlight required

1541 * differences with a specific color, and highlight unmergeable differences with another color.

1542 *

1543 * @param event

1544 * the erase item event.

1545 */

1546 private void handleEraseItemEvent(Event event) {

1547 TreeItem item = (TreeItem)event.item;

                EObject dataItem = EMFCompareStructureMergeViewer.getDataOfTreeNodeOfAdapter(item.getData());

                if (dataItem != null) {

                        final Set<Diff> requires = dependencyData.getRequires();

                        final Set<Diff> rejectedDiffs = dependencyData.getRejections();

1552 final GC g = event.gc;

                        if (requires.contains(dataItem)) {

                                paintItemBackground(g, item, fColors.getRequiredFillColor());

                        } else if (rejectedDiffs.contains(dataItem)) {

                                paintItemBackground(g, item, fColors.getUnmergeableFillColor());

1557 }

1558 }

1559 }

1560

1561 /**

1562 * Paint the background of the given item with the given color.

1563 *

1564 * @param g

1565 * the GC associated to the item.

1566 * @param item

1567 * the given item.

1568 * @param color

1569 * the given color.

1570 */

        private void paintItemBackground(GC g, TreeItem item, Color color) {

1572 Rectangle itemBounds = item.getBounds();

1573 Tree tree = item.getParent();

1574 Rectangle areaBounds = tree.getClientArea();

                g.setClipping(areaBounds.x, itemBounds.y, areaBounds.width, itemBounds.height);

1576 g.setBackground(color);

                g.fillRectangle(areaBounds.x, itemBounds.y, areaBounds.width, itemBounds.height);

1578 }

1579

1580 /**

1581 * Returns a problem indication composite for the given diagnostic. If a problem indication composite

1582 * already exists, the existing one is returned. If no composite exists, a new composite is created if the

1583 * severity of the provided diagnostic is anything besides OK. If no composite exists and the severity

1584 * does not warrant the creation of a new composite, this method returns null.

1585 *

1586 * @param diagnostic

1587 * comparison diagnostic

1588 * @return the existing or a newly created problem indication composite or null if no indication is

1589 * necessary

1590 */

1591 private ProblemIndicationComposite getProblemIndication(Diagnostic diagnostic) {

1592 Assert.isNotNull(diagnostic);

                int lastEditorPage = getPageCount() - 1;

1594 ProblemIndicationComposite problemIndicationComposite = null;

                if (lastEditorPage >= 0 && getItemControl(lastEditorPage) instanceof ProblemIndicationComposite) {

                        problemIndicationComposite = ((ProblemIndicationComposite)getItemControl(lastEditorPage));

                } else if (diagnostic.getSeverity() != Diagnostic.OK && !getControl().isDisposed()) {

                        problemIndicationComposite = new ProblemIndicationComposite(getControl(), SWT.NONE);

1599 createItem(++lastEditorPage, problemIndicationComposite);

                        getControl().getItem(lastEditorPage)

                                        .setText(CommonUIPlugin.getPlugin().getString("_UI_Problems_label")); //$NON-NLS-1$

1602 showTabs();

1603 }

1604 return problemIndicationComposite;

1605 }

1606

1607 /**

1608 * Updates the problem indication for the provided diagnostic. If everything is {@link Diagnostic#OK} and

1609 * no problem indication is available, this method does nothing. In any other case, the existing or a

1610 * newly created problem indication is updated and automatically revealed if the diagnostics

1611 * {@link Diagnostic#getSeverity() severity} is anything besides {@link Diagnostic#OK} and

1612 * {@link Diagnostic#WARNING}.

1613 *

1614 * @param diagnostic

1615 * comparison diagnostic

1616 */

1617 private void updateProblemIndication(Diagnostic diagnostic) {

1618 ProblemIndicationComposite problemIndicationComposite = getProblemIndication(diagnostic);

                if (problemIndicationComposite != null) {

1620 problemIndicationComposite.setDiagnostic(diagnostic);

                        if (diagnostic.getSeverity() != Diagnostic.OK && diagnostic.getSeverity() != Diagnostic.WARNING) {

1622 // reveal problem indication composite (last editor page)

                                int lastEditorPage = getPageCount() - 1;

1624 setActivePage(lastEditorPage);

                                updateLayout(false, true);

1626 }

1627 }

1628 }

1629

1630 private void showTabs() {

                if (getPageCount() > 1) {

                        getControl().getItem(0).setText(

                                        EMFCompareIDEUIMessages.getString("EMFCompareStructureMergeViewer.tabItem.0.title")); //$NON-NLS-1$

                        getControl().setTabHeight(SWT.DEFAULT);

                        Point point = getControl().getSize();

                        getControl().setSize(point.x, point.y - 6);

1637 }

1638 }

1639

1640 private void hideTabs() {

                if (getPageCount() <= 1) {

                        getControl().getItem(0).setText(""); //$NON-NLS-1$

                        getControl().setTabHeight(1);

                        Point point = getControl().getSize();

                        getControl().setSize(point.x, point.y + 6);

1646 }

1647 }

1648

        private void setActivePage(int pageIndex) {

                Assert.isTrue(pageIndex >= 0 && pageIndex < getPageCount());

                getControl().setSelection(pageIndex);

1652 }

1653

1654 private int getPageCount() {

1655 // May not have been created yet, or may have been disposed.

                if (getControl() != null && !getControl().isDisposed()) {

                        return getControl().getItemCount();

1658 }

1659 return 0;

1660 }

1661

        private Control getItemControl(int itemIndex) {

                CTabItem item = getControl().getItem(itemIndex);

                if (item != null) {

1665 return item.getControl();

1666 }

1667 return null;

1668 }

1669

1670 private static void unload(ResourceSet resourceSet) {

                if (resourceSet != null) {

                        for (Resource resource : resourceSet.getResources()) {

1673 resource.unload();

1674 }

                        resourceSet.getResources().clear();

1676 }

1677 }

1678

1679 private static ResourceSet getResourceSet(EObject eObject) {

                if (eObject != null) {

1681 Resource eResource = eObject.eResource();

                        if (eResource != null) {

1683 return eResource.getResourceSet();

1684 }

1685 }

1686 return null;

1687 }

1688

1689 /**

1690 * {@inheritDoc}

1691 *

1692 * @see org.eclipse.jface.viewers.StructuredViewer#internalRefresh(java.lang.Object)

1693 */

1694 @Override

1695 protected void internalRefresh(Object element) {

1696 // Postpones the refresh if the content provider is in pending mode

                getContentProvider().runWhenReady(IN_UI_SYNC, new Runnable() {

1698

1699 public void run() {

1700 getViewer().refresh();

1701 }

1702 });

1703 // Updates dependency data when the viewer has been refreshed and the content provider is ready.

                getContentProvider().runWhenReady(IN_UI_SYNC, new Runnable() {

1705 public void run() {

1706 updateHighlightRelatedChanges(getSelection());

1707 }

1708 });

1709 // Needs dependency data however do not need to be run in UI thread

                getContentProvider().runWhenReady(IN_UI_ASYNC, new Runnable() {

1711

1712 public void run() {

1713 refreshTitle();

1714 }

1715 });

1716

1717 }

1718

1719 /**

1720 * Handles changes to the UI-related preferences in the {@link #preferenceStore}.

1721 *

1722 * @param event

1723 * change event for a preference property

1724 */

1725 protected void handlePreferenceChangedEvent(PropertyChangeEvent event) {

                if (event.getProperty() == EMFCompareUIPreferences.EDITOR_TREE_HIGHLIGHT_RELATED_CHANGES) {

                        boolean highlightRelatedChanges = Boolean.parseBoolean(event.getNewValue().toString());

1728 if (highlightRelatedChanges) {

1729 updateHighlightRelatedChanges(getSelection());

1730 } else {

1731 clearHighlightRelatedChanges();

1732 }

1733 }

1734 }

1735

1736 private void handleSelectionChangedEvent(SelectionChangedEvent event) {

                if (!Objects.equal(currentSelection, event.getSelection())) {

                        this.currentSelection = event.getSelection();

                        updateHighlightRelatedChanges(event.getSelection());

1740 }

1741 }

1742

1743 /**

1744 * We need to call redraw() on the tree and the tree ruler because getControl().redraw() doesn't propagate

1745 * the redraw on its sub components under windows platform.

1746 */

1747 private void internalRedraw() {

                Tree tree = getViewer().getTree();

                if (!tree.isDisposed()) {

1750 tree.redraw();

                        if (!treeRuler.isDisposed()) {

1752 treeRuler.redraw();

1753 }

1754 }

1755 }

1756

1757 private static class TitleBuilder {

1758

1759 private final Comparison comparison;

1760

1761 private final IDifferenceGroupProvider groupProvider;

1762

                private final Predicate<? super EObject> filterPredicate;

1764

                private final Map<Object, Boolean> visited = Maps.newHashMap();

1766

1767 private int diffsCount;

1768

1769 private int visibleDiffsCount;

1770

1771 private int diffsToMergeCount;

1772

1773 public TitleBuilder(EMFCompareConfiguration configuration) {

1774 comparison = configuration.getComparison();

                        groupProvider = configuration.getStructureMergeViewerGrouper().getProvider();

                        filterPredicate = configuration.getStructureMergeViewerFilter().getAggregatedPredicate();

1777 }

1778

                void visit(TreeNode node, boolean parentApplies) {

                        boolean applies = parentApplies && filterPredicate.apply(node);

1781 EObject data = node.getData();

1782 if (data instanceof Diff) {

1783 // If we haven't visited it before...

                                Boolean visitedApplies = visited.put(data, Boolean.valueOf(applies));

                                if (visitedApplies == null) {

1786 // Count it.

1787 ++diffsCount;

1788 }

1789

1790 // If it's visible...

1791 if (applies) {

1792 // If we didn't visit it as visible before...

                                        if (!Boolean.TRUE.equals(visitedApplies)) {

1794 // Count it as visible.

1795 ++visibleDiffsCount;

1796

1797 // And if it's not unresolved, count it has needing to be merged.

1798 Diff diff = (Diff)data;

                                                if (diff.getState() == DifferenceState.UNRESOLVED) {

1800 ++diffsToMergeCount;

1801 }

1802 }

                                } else if (Boolean.TRUE.equals(visitedApplies)) {

1804 // If it was previously counted as visible, but here it's not visible, replace the state

1805 // to indicate it was visible and was counted as visible before.

                                        visited.put(data, Boolean.TRUE);

1807 }

1808 }

1809

                        for (TreeNode childNode : node.getChildren()) {

1811 visit(childNode, applies);

1812 }

1813 }

1814

1815 @Override

1816 public String toString() {

                        for (IDifferenceGroup group : groupProvider.getGroups(comparison)) {

                                for (TreeNode node : group.getChildren()) {

                                        visit(node, true);

1820 }

1821 }

1822

1823 @SuppressWarnings("boxing")

1824 String titleArgument = EMFCompareIDEUIMessages.getString(

1825 "EMFCompareStructureMergeViewer.titleDesc", //$NON-NLS-1$

1826 diffsToMergeCount, visibleDiffsCount, diffsCount - visibleDiffsCount);

1827 return titleArgument;

1828 }

1829 }

1830 }