Public Git Hosting - EMFCompare2.git/blob - plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/contentmergeviewer/EMFCompareContentMergeViewer.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 462863

11 * Stefan Dirix - bug 473985

12 * Philip Langer - bug 516645

13 * Martin Fleck - bug 514079

14 *******************************************************************************/

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

import com.google.common.base.Predicate;

import com.google.common.eventbus.Subscribe;

20 import java.util.Collection;

21 import java.util.EventObject;

22 import java.util.Iterator;

23 import java.util.Map;

24 import java.util.ResourceBundle;

import java.util.concurrent.atomic.AtomicBoolean;

import org.eclipse.compare.contentmergeviewer.ContentMergeViewer;

import org.eclipse.compare.internal.CompareHandlerService;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.Platform;

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.AdapterFactory;

import org.eclipse.emf.compare.Diff;

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

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

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

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.util.DynamicObject;

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.mergeresolution.MergeResolutionManager;

import org.eclipse.emf.compare.rcp.ui.contentmergeviewer.accessor.ICompareAccessor;

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

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

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

import org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl.MergeViewerItem;

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

import org.eclipse.emf.compare.rcp.ui.mergeviewer.ICompareColor;

import org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer;

import org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide;

import org.eclipse.emf.compare.rcp.ui.mergeviewer.item.IMergeViewerItem;

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

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

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

import org.eclipse.emf.ecore.EObject;

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

import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;

import org.eclipse.emf.edit.domain.EditingDomain;

import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;

import org.eclipse.emf.edit.ui.view.ExtendedPropertySheetPage;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.ActionContributionItem;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.action.IContributionItem;

import org.eclipse.jface.action.ToolBarManager;

import org.eclipse.jface.viewers.IContentProvider;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeSelection;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.ControlListener;

import org.eclipse.swt.events.DisposeEvent;

import org.eclipse.swt.events.DisposeListener;

import org.eclipse.swt.events.PaintEvent;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Sash;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IViewPart;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.actions.ActionFactory;

import org.eclipse.ui.menus.IMenuService;

import org.eclipse.ui.part.IPage;

import org.eclipse.ui.services.IServiceLocator;

import org.eclipse.ui.themes.ITheme;

import org.eclipse.ui.themes.IThemeManager;

import org.eclipse.ui.views.properties.PropertySheet;

103

104 /**

105 * @author <a href="mailto:mikael.barbero@obeo.fr">Mikael Barbero</a>

106 */

public abstract class EMFCompareContentMergeViewer extends ContentMergeViewer implements ISelectionChangedListener, ICompareColor.Provider, IAdaptable, CommandStackListener {

108

        private static final String HANDLER_SERVICE = "fHandlerService"; //$NON-NLS-1$

110

111 /**

112 * Width of center bar

113 */

114 protected static final int CENTER_WIDTH = 34;

115

116 private IMergeViewer fAncestor;

117

118 private IMergeViewer fLeft;

119

120 private IMergeViewer fRight;

121

        private final AtomicBoolean fSyncingSelections = new AtomicBoolean(false);

123

124 private EMFCompareColor fColors;

125

126 private final DynamicObject fDynamicObject;

127

128 private UndoAction undoAction;

129

130 private RedoAction redoAction;

131

132 private AdapterFactoryContentProvider fAdapterFactoryContentProvider;

133

        private Predicate<? super EObject> differenceFilterPredicate;

135

136 private IDifferenceGroupProvider differenceGroupProvider;

137

138 private MergeResolutionManager mergeResolutionManager;

139

140 private Boolean fIsMirrored;

141

142 /**

143 * @param style

144 * @param bundle

145 * @param cc

146 */

        protected EMFCompareContentMergeViewer(int style, ResourceBundle bundle, EMFCompareConfiguration cc) {

                super(style, new EMFCompareContentMergeViewerResourceBundle(bundle), cc);

149

                fDynamicObject = new DynamicObject(this);

151

                if (getCompareConfiguration().getAdapterFactory() != null) {

153 fAdapterFactoryContentProvider = new AdapterFactoryContentProvider(

154 getCompareConfiguration().getAdapterFactory());

155 }

156

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

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

159

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

                getCompareConfiguration().getEventBus().register(this);

162

163 mergeResolutionManager = new MergeResolutionManager(

                                EMFCompareIDEUIPlugin.getDefault().getMergeResolutionListenerRegistry());

165 }

166

167 @Subscribe

168 public void handleAdapterFactoryChange(IAdapterFactoryChange event) {

169 AdapterFactory oldValue = event.getOldValue();

170 AdapterFactory newValue = event.getNewValue();

                if (oldValue != null) {

172 fAdapterFactoryContentProvider.dispose();

173 }

174 if (newValue != oldValue) {

                        fAdapterFactoryContentProvider = new AdapterFactoryContentProvider(newValue);

176 }

177 }

178

179 @Subscribe

180 public void colorChanged(

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

182 getControl().redraw();

183 }

184

185 /**

186 * {@inheritDoc}

187 *

188 * @see org.eclipse.emf.compare.ide.ui.internal.configuration.EMFCompareConfiguration#editingDomainChange(org.eclipse.emf.compare.domain.ICompareEditingDomain,

189 * org.eclipse.emf.compare.domain.ICompareEditingDomain)

190 */

191 @Subscribe

192 public void handleEditingDomainChange(ICompareEditingDomainChange event) {

193 ICompareEditingDomain oldValue = event.getOldValue();

194 ICompareEditingDomain newValue = event.getNewValue();

195 editingDomainChange(oldValue, newValue);

196 }

197

        protected void editingDomainChange(ICompareEditingDomain oldValue, ICompareEditingDomain newValue) {

                if (oldValue != null) {

200 ICompareCommandStack commandStack = oldValue.getCommandStack();

                        commandStack.removeCommandStackListener(this);

202 }

203 if (newValue != oldValue) {

                        if (newValue != null) {

205 ICompareCommandStack commandStack = newValue.getCommandStack();

                                commandStack.addCommandStackListener(this);

                                setLeftDirty(commandStack.isLeftSaveNeeded());

                                setRightDirty(commandStack.isRightSaveNeeded());

209 }

210 undoAction.setEditingDomain(newValue);

211 redoAction.setEditingDomain(newValue);

212 }

213 }

214

215 @Subscribe

216 public void handleDifferenceFiltersChange(IDifferenceFilterChange event) {

217 differenceFilterPredicate = event.getPredicate();

218 redrawCenterControl();

219 }

220

221 /**

222 * @return the differenceFilterPredicate

223 */

        protected final Predicate<? super EObject> getDifferenceFilterPredicate() {

                if (differenceFilterPredicate == null) {

                        differenceFilterPredicate = getCompareConfiguration().getStructureMergeViewerFilter()

227 .getAggregatedPredicate();

228 }

229 return differenceFilterPredicate;

230 }

231

232 @Subscribe

233 public void handleDifferenceGroupProviderChange(IDifferenceGroupProviderChange event) {

234 differenceGroupProvider = event.getDifferenceGroupProvider();

235 redrawCenterControl();

236 }

237

238 /**

239 * @return the differenceGroupProvider

240 */

241 protected final IDifferenceGroupProvider getDifferenceGroupProvider() {

                if (differenceGroupProvider == null) {

                        differenceGroupProvider = getCompareConfiguration().getStructureMergeViewerGrouper()

244 .getProvider();

245 }

246 return differenceGroupProvider;

247 }

248

249 /**

250 * {@inheritDoc}

251 *

252 * @see org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.ICompareColorProvider#getCompareColor()

253 */

254 public ICompareColor getCompareColor() {

255 return fColors;

256 }

257

258 /**

259 * {@inheritDoc}

260 *

261 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#updateContent(java.lang.Object,

262 * java.lang.Object, java.lang.Object)

263 */

264 @Override

        protected void updateContent(Object ancestor, Object left, Object right) {

266 fAncestor.setInput(ancestor);

267 fLeft.setInput(left);

268 fRight.setInput(right);

269

270 IMergeViewerItem leftInitialItem = null;

271 if (left instanceof ICompareAccessor) {

                        leftInitialItem = ((ICompareAccessor)left).getInitialItem();

273 }

274 // Bug 458818: In some cases, the left initial item is null because

275 // the item that should be selected has been deleted on the right

276 // and this delete is part of a conflict

                if (leftInitialItem == null) {

278 if (right instanceof ICompareAccessor) {

                                IMergeViewerItem rightInitialItem = ((ICompareAccessor)right).getInitialItem();

                                if (rightInitialItem == null) {

                                        fLeft.setSelection(StructuredSelection.EMPTY, true);

282 } else {

                                        fRight.setSelection(new StructuredSelection(rightInitialItem), true);

284 }

285 } else {

286 // Strange case: left is an ICompareAccessor but right is not?

                                fLeft.setSelection(StructuredSelection.EMPTY, true);

288 }

289 } else {

290 // others will synchronize on this one :)

                        fLeft.setSelection(new StructuredSelection(leftInitialItem), true);

292 }

293 redrawCenterControl();

294 }

295

296 /**

297 * Inhibits this method to avoid asking to save on each input change!!

298 *

299 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#doSave(java.lang.Object,

300 * java.lang.Object)

301 */

302 @Override

        protected boolean doSave(Object newInput, Object oldInput) {

304 return false;

305 }

306

307 /**

308 * {@inheritDoc}

309 *

310 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#createControls(org.eclipse.swt.widgets.Composite)

311 */

312 @Override

313 protected void createControls(Composite composite) {

                fAncestor = createMergeViewer(composite, MergeViewerSide.ANCESTOR);

                fAncestor.addSelectionChangedListener(this);

316

                fLeft = createMergeViewer(composite, MergeViewerSide.LEFT);

                fLeft.addSelectionChangedListener(this);

319

                fRight = createMergeViewer(composite, MergeViewerSide.RIGHT);

                fRight.addSelectionChangedListener(this);

322

323 final ITheme currentTheme = getCurrentTheme();

324

                boolean leftIsLocal = getCompareConfiguration().getBooleanProperty("LEFT_IS_LOCAL", false);

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

327 getCompareConfiguration().getEventBus());

328

                composite.addControlListener(new ControlListener() {

330 public void controlResized(ControlEvent e) {

331 redrawCenterControl();

332 }

333

334 public void controlMoved(ControlEvent e) {

335 // Do nothing.

336 }

337 });

338 }

339

340 /**

341 * Determines the current used theme.

342 *

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

344 */

345 private ITheme getCurrentTheme() {

                if (PlatformUI.isWorkbenchRunning()) {

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

                        if (themeManager != null) {

349 return themeManager.getCurrentTheme();

350 }

351 }

352 return null;

353 }

354

355 /**

356 * {@inheritDoc}

357 *

358 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#createToolItems(org.eclipse.jface.action.ToolBarManager)

359 */

360 @Override

        protected void createToolItems(final ToolBarManager toolBarManager) {

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

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

364

365 // switch left and right view action, may be null -> set the initial toggle state of the button

                Action switchLeftAndRightAction = MirrorUtil.getAction(this);

                if (switchLeftAndRightAction != null) {

                        switchLeftAndRightAction.setChecked(isMirrored());

369 }

370

                IContributionItem[] items = toolBarManager.getItems();

372 for (IContributionItem iContributionItem : items) {

373 if (iContributionItem instanceof ActionContributionItem) {

                                IAction action = ((ActionContributionItem)iContributionItem).getAction();

375 String id = action.getActionDefinitionId();

                                if ("org.eclipse.compare.copyAllLeftToRight".equals(id)) {

377 toolBarManager.remove(iContributionItem);

                                } else if ("org.eclipse.compare.copyAllRightToLeft".equals(id)) {

379 toolBarManager.remove(iContributionItem);

380 }

381 }

382 }

383

384 // Add extension point contributions to the content merge viewer toolbar

                if (PlatformUI.isWorkbenchRunning()) {

386 IServiceLocator workbench = PlatformUI.getWorkbench();

                        final IMenuService menuService = (IMenuService)workbench.getService(IMenuService.class);

                        if (menuService != null) {

389 menuService.populateContributionManager(toolBarManager,

390 "toolbar:org.eclipse.emf.compare.contentmergeviewer.toolbar"); //$NON-NLS-1$

                                toolBarManager.getControl().addDisposeListener(new DisposeListener() {

392 public void widgetDisposed(DisposeEvent e) {

393 menuService.releaseContributions(toolBarManager);

394 // re-populate and release menu contributions to fix memory leak (see bug 516645)

                                                menuService.populateContributionManager(toolBarManager, "nothing"); //$NON-NLS-1$

396 menuService.releaseContributions(toolBarManager);

397 }

398 });

399 }

400 }

401 }

402

403 public void commandStackChanged(EventObject event) {

404 undoAction.update();

405 redoAction.update();

406

                if (getCompareConfiguration().getEditingDomain() != null) {

                        ICompareCommandStack commandStack = getCompareConfiguration().getEditingDomain()

409 .getCommandStack();

                        setLeftDirty(commandStack.isLeftSaveNeeded());

                        setRightDirty(commandStack.isRightSaveNeeded());

412 }

413

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

415 if (mostRecentCommand instanceof ICompareCopyCommand) {

                        SWTUtil.safeRefresh(this, true, false);

                } else if (mostRecentCommand != null) {

418 // Model has changed, but not by EMFCompare. Typical case is update from properties view.

419 // In this case, we don't want to refresh all viewers and lost selected element, just refresh

420 // appropriate side and keep selected element.

421 IMergeViewer affectedMergeViewer = getAffectedMergeViewer(mostRecentCommand);

422 if (affectedMergeViewer instanceof Viewer) {

                                SWTUtil.safeRefresh(((Viewer)affectedMergeViewer), true, false);

424 }

425 }

426 }

427

428 /**

429 * Get the merge viewer affected by this command.

430 *

431 * @param command

432 * the command.

433 * @return the merge viewer affected by this command if found, null otherwise.

434 */

435 private IMergeViewer getAffectedMergeViewer(Command command) {

436 final IMergeViewer viewer;

                final IMergeViewer leftMergeViewer = this.getLeftMergeViewer();

                final ISelection leftSelection = leftMergeViewer.getSelection();

                final Collection<?> affectedObjects = command.getAffectedObjects();

                if (affectedObjects != null && !affectedObjects.isEmpty()) {

                        Object firstAffectedObject = affectedObjects.iterator().next();

                        if (firstAffectedObject.equals(getElement(leftSelection, MergeViewerSide.LEFT))) {

443 viewer = leftMergeViewer;

                        } else if (firstAffectedObject.equals(getElement(leftSelection, MergeViewerSide.RIGHT))) {

                                viewer = this.getRightMergeViewer();

                        } else if (firstAffectedObject.equals(getElement(leftSelection, MergeViewerSide.ANCESTOR))) {

                                viewer = this.getAncestorMergeViewer();

448 } else {

449 viewer = null;

450 }

451 } else {

452 viewer = null;

453 }

454 return viewer;

455 }

456

457 /**

458 * From the given selection, get the model element from the given side.

459 *

460 * @param selection

461 * the given selection.

462 * @param side

463 * the given side.

464 * @return the model element from the given side if it exists, null otherwise.

465 */

        private Object getElement(ISelection selection, MergeViewerSide side) {

467 final Object element;

468 if (selection instanceof TreeSelection) {

                        Object firstElement = ((TreeSelection)selection).getFirstElement();

470 if (firstElement instanceof IMergeViewerItem) {

                                if (MergeViewerSide.LEFT == side) {

                                        element = ((IMergeViewerItem)firstElement).getLeft();

                                } else if (MergeViewerSide.RIGHT == side) {

                                        element = ((IMergeViewerItem)firstElement).getRight();

                                } else if (MergeViewerSide.ANCESTOR == side) {

                                        element = ((IMergeViewerItem)firstElement).getAncestor();

477 } else {

478 element = null;

479 }

480 } else {

481 element = null;

482 }

483 } else {

484 element = null;

485 }

486 return element;

487 }

488

489 /**

490 * {@inheritDoc}

491 *

492 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#copy(boolean)

493 */

494 @Override

        protected void copy(final boolean leftToRight) {

496 // do nothing, merge is done through merge actions in structure merge viewer.

497 }

498

499 /**

500 * {@inheritDoc}

501 *

502 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#handleResizeAncestor(int, int, int, int)

503 */

504 @Override

        protected void handleResizeAncestor(int x, int y, int width, int height) {

                if (width > 0) {

                        getAncestorMergeViewer().getControl().setVisible(true);

                        getAncestorMergeViewer().getControl().setBounds(x, y, width, height);

509 } else {

                        getAncestorMergeViewer().getControl().setVisible(false);

511 }

512 }

513

514 /**

515 * {@inheritDoc}

516 *

517 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#handleResizeLeftRight(int, int, int,

518 * int, int, int)

519 */

520 @Override

        protected void handleResizeLeftRight(int x, int y, int width1, int centerWidth, int width2, int height) {

                fLeft.getControl().setBounds(x, y, width1, height);

                fRight.getControl().setBounds(x + width1 + centerWidth, y, width2, height);

524 }

525

        protected abstract IMergeViewer createMergeViewer(Composite parent, MergeViewerSide side);

527

528 @Override

529 protected final int getCenterWidth() {

530 return CENTER_WIDTH;

531 }

532

533 protected final CompareHandlerService getHandlerService() {

                return (CompareHandlerService)fDynamicObject.get(HANDLER_SERVICE);

535 }

536

537 /**

538 * {@inheritDoc}

539 *

540 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#getControl()

541 */

542 @Override

543 public Composite getControl() {

                return (Composite)super.getControl();

545 }

546

547 /**

548 * {@inheritDoc}

549 *

550 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#createCenterControl(org.eclipse.swt.widgets.Composite)

551 */

552 @Override

        protected Control createCenterControl(final Composite parent) {

                final Sash ret = (Sash)super.createCenterControl(parent);

555

                final SelectionAdapter selectionListener = new SelectionAdapter() {

557 @Override

558 public void widgetSelected(SelectionEvent e) {

                                SWTUtil.safeAsyncExec(new Runnable() {

560 public void run() {

561 parent.layout();

562 }

563 });

564 }

565 };

566

567 ret.addSelectionListener(selectionListener);

568

                final PaintListener paintListener = new PaintListener() {

570 public void paintControl(PaintEvent e) {

571 paintCenter(e.gc);

572 }

573 };

574 ret.addPaintListener(paintListener);

575

                ret.addDisposeListener(new DisposeListener() {

577 public void widgetDisposed(DisposeEvent e) {

578 ret.removePaintListener(paintListener);

579 ret.removeSelectionListener(selectionListener);

580 }

581 });

582

583 return ret;

584 }

585

586 protected abstract void paintCenter(GC g);

587

        public Object getAdapter(@SuppressWarnings("rawtypes") Class adapter) {

                if (adapter == CompareHandlerService.class) {

590 return getHandlerService();

591 }

                if (adapter == CompareHandlerService[].class) {

593 return new CompareHandlerService[] {getHandlerService(), };

594 }

595 return null;

596 }

597

598 /**

599 * @return the fAncestor

600 */

601 protected IMergeViewer getAncestorMergeViewer() {

602 return fAncestor;

603 }

604

605 /**

606 * @return the fLeft

607 */

608 protected IMergeViewer getLeftMergeViewer() {

609 return fLeft;

610 }

611

612 /**

613 * @return the fRight

614 */

615 protected IMergeViewer getRightMergeViewer() {

616 return fRight;

617 }

618

619 /**

620 * {@inheritDoc}

621 *

622 * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)

623 */

624 public void selectionChanged(SelectionChangedEvent event) {

625 synchronizeSelection(event);

626 updateToolItems();

627 }

628

629 private void synchronizeSelection(SelectionChangedEvent event) {

                if (fSyncingSelections.compareAndSet(false, true)) { // prevents stack overflow :)

631 try {

632 ISelection selection = event.getSelection();

633 updatePropertiesView(selection);

                                fLeft.setSelection(selection, true);

                                fRight.setSelection(selection, true);

                                fAncestor.setSelection(selection, true);

637 } finally {

                                fSyncingSelections.set(false);

639 }

640 }

641

642 }

643

644 /**

645 * Update the properties view with the given selection.

646 *

647 * @param selection

648 * the given selection.

649 */

650 private void updatePropertiesView(ISelection selection) {

                if (!PlatformUI.isWorkbenchRunning()) {

652 // no update of property view outside of workbench

653 return;

654 }

655

656 if (selection instanceof StructuredSelection) {

657 StructuredSelection structuredSelection = (StructuredSelection)selection;

                        IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();

                        final ExtendedPropertySheetPage propertySheetPage = getExtendedPropertySheetPage(page);

                        if (propertySheetPage != null) {

661 StructuredSelection selectionForPropertySheet = null;

                                final IWorkbenchPart activePart = page.getActivePart();

663 Object firstElement = structuredSelection.getFirstElement();

664 if (firstElement instanceof MergeViewerItem) {

665 MergeViewerItem mergeViewerItem = (MergeViewerItem)firstElement;

666 MergeViewerSide side = mergeViewerItem.getSide();

                                        Object newSelectedObject = mergeViewerItem.getSideValue(side);

668 propertySheetPage.setPropertySourceProvider(fAdapterFactoryContentProvider);

                                        getControl().addDisposeListener(new DisposeListener() {

670 public void widgetDisposed(DisposeEvent e) {

                                                        propertySheetPage.selectionChanged(activePart, null);

                                                        propertySheetPage.setPropertySourceProvider(null);

673 }

674 });

                                        if (newSelectedObject != null) {

676 if (newSelectedObject instanceof EObject) {

                                                        manageReadOnly((EObject)newSelectedObject, side);

678 }

                                                selectionForPropertySheet = new StructuredSelection(newSelectedObject);

                                                propertySheetPage.selectionChanged(activePart, selectionForPropertySheet);

681 }

682 }

                                if (selectionForPropertySheet == null) {

                                        selectionForPropertySheet = new StructuredSelection(new Object());

                                        propertySheetPage.selectionChanged(activePart, selectionForPropertySheet);

686 }

687 }

688 }

689 }

690

691 /**

692 * Returns the extended property sheet page.

693 *

694 * @return the extended property sheet page.

695 */

696 private ExtendedPropertySheetPage getExtendedPropertySheetPage(IWorkbenchPage activePage) {

697 ExtendedPropertySheetPage propertyPage = null;

                if (activePage != null) {

                        IViewPart view = activePage.findView("org.eclipse.ui.views.PropertySheet"); //$NON-NLS-1$

                        if (view != null) {

701 if (view instanceof PropertySheet) {

702 PropertySheet propertySheet = (PropertySheet)view;

703 IPage currentPage = propertySheet.getCurrentPage();

704 if (currentPage instanceof ExtendedPropertySheetPage) {

705 propertyPage = (ExtendedPropertySheetPage)currentPage;

706 } else {

707 IEditorPart activeEditor = activePage.getActiveEditor();

                                                if (activeEditor != null && Platform.getAdapterManager().hasAdapter(activeEditor,

709 "org.eclipse.ui.views.properties.IPropertySheetPage")) { //$NON-NLS-1$

                                                        propertySheet.partActivated(activePage.getActivePart());

711 }

712 }

713

714 }

715 }

716 }

717 return propertyPage;

718 }

719

720 /**

721 * Manages the read-only state of the properties sheet page for the given selected object.

722 *

723 * @param selectedObject

724 * the given selected object.

725 * @param side

726 * the side of the selected object.

727 */

        private void manageReadOnly(EObject selectedObject, MergeViewerSide side) {

                if (MergeViewerSide.LEFT == side) {

                        if (!getCompareConfiguration().isLeftEditable()) {

731 setToReadOnly(selectedObject);

732 }

                } else if (MergeViewerSide.RIGHT == side) {

                        if (!getCompareConfiguration().isRightEditable()) {

735 setToReadOnly(selectedObject);

736 }

                } else if (MergeViewerSide.ANCESTOR == side) {

738 setToReadOnly(selectedObject);

739 }

740 }

741

742 /**

743 * Sets the resource of the selected object to read-only in the appropriate editing domain.

744 *

745 * @param selectedObject

746 * the given selected object.

747 */

748 private void setToReadOnly(EObject selectedObject) {

                EditingDomain editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(selectedObject);

750 if (editingDomain instanceof AdapterFactoryEditingDomain) {

751 Resource r = selectedObject.eResource();

                        Map<Resource, Boolean> resourceToReadOnlyMap = ((AdapterFactoryEditingDomain)editingDomain)

753 .getResourceToReadOnlyMap();

                        if (!resourceToReadOnlyMap.containsKey(r)) {

                                resourceToReadOnlyMap.put(r, Boolean.TRUE);

756 }

757 }

758 }

759

760 /**

761 * Checks the element selected in the given viewer in order to determine whether it can be adapted into a

762 * Diff.

763 *

764 * @param viewer

765 * The viewer which selection is to be checked.

766 * @return The first of the Diffs selected in the given viewer, if any.

767 */

768 protected Diff getDiffFrom(IMergeViewer viewer) {

769 Diff diff = null;

                final ISelection selection = viewer.getSelection();

                if (selection instanceof IStructuredSelection && !selection.isEmpty()) {

                        final Iterator<?> selectedElements = ((IStructuredSelection)selection).iterator();

                        while (diff == null && selectedElements.hasNext()) {

                                final Object element = selectedElements.next();

775 if (element instanceof IMergeViewerItem) {

                                        diff = ((IMergeViewerItem)element).getDiff();

777 }

778 }

779 }

780 return diff;

781 }

782

783 /**

784 * {@inheritDoc}

785 *

786 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#handleDispose(org.eclipse.swt.events.DisposeEvent)

787 */

788 @Override

789 protected void handleDispose(DisposeEvent event) {

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

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

792 differenceGroupProvider = null;

793 undoAction = null;

794 redoAction = null;

                if (fAdapterFactoryContentProvider != null) {

                        fAdapterFactoryContentProvider.setAdapterFactory(null);

797 }

                if (fColors != null) {

799 fColors.dispose();

800 }

                super.handleDispose(event);

802 }

803

804 protected final void redrawCenterControl() {

                if (getCenterControl() != null) {

                        SWTUtil.safeRedraw(getCenterControl(), false);

807 }

808 }

809

810 /**

811 * {@inheritDoc}

812 *

813 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#getCompareConfiguration()

814 */

815 @Override

816 protected EMFCompareConfiguration getCompareConfiguration() {

                return (EMFCompareConfiguration)super.getCompareConfiguration();

818 }

819

820 @Override

        protected void flushContent(Object input, IProgressMonitor monitor) {

                super.flushContent(input, monitor);

823 mergeResolutionManager.handleFlush(input);

824 }

825

826 /**

827 * Queries the compare configuration whether the left and right side of the viewer should be mirrored.

828 *

829 * @return true if the left and right side of the viewer should be mirrored, false otherwise

830 */

831 protected boolean isMirrored() {

                return MirrorUtil.isMirrored(getCompareConfiguration());

833 }

834

835 /**

836 * Returns the correctly mirrored side for this viewer based on the current {@link #isMirrored() mirrored

837 * state}. If this viewer is not mirrored, the side is returned as is, otherwise its opposite site is

838 * returned.

839 *

840 * @param side

841 * merge viewer side

842 * @return side to be used based on the current mirror state.

843 */

844 protected MergeViewerSide computeSide(MergeViewerSide side) {

845 if (isMirrored()) {

846 return side.opposite();

847 }

848 return side;

849 }

850

851 /**

852 * Returns the content provider that should be used when this viewer is NOT {@link #isMirrored()

853 * mirrored}.

854 *

855 * @return unmirrored content provider

856 */

857 protected abstract IContentProvider getUnmirroredContentProvider();

858

859 /**

860 * Returns the content provider that should be used when this viewer is {@link #isMirrored() mirrored}.

861 *

862 * @return mirrored content provider

863 */

864 protected abstract IContentProvider getMirroredContentProvider();

865

866 /**

867 * Sets the viewers {@link #isMirrored() mirrored} state and triggers an {@link #updateMirrored(boolean)

868 * update}, if necessary.

869 */

        protected void setMirrored(boolean isMirrored) {

                if (fIsMirrored == null || fIsMirrored.booleanValue() != isMirrored) {

                        fIsMirrored = Boolean.valueOf(isMirrored);

873 updateMirrored(isMirrored);

874 }

875 }

876

877 /**

878 * Updates the viewer based on its {@link #isMirrored() mirrored} state.

879 */

        protected void updateMirrored(boolean isMirrored) {

881 if (isMirrored) {

882 setContentProvider(getMirroredContentProvider());

883 } else {

884 setContentProvider(getUnmirroredContentProvider());

885 }

886 }

887 }