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

8 * Contributors:

9 * Obeo - initial API and implementation

10 *******************************************************************************/

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

import com.google.common.collect.HashMultimap;

import com.google.common.collect.Iterables;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.common.collect.Multimap;

import com.google.common.collect.Sets;

20 import java.util.Collection;

21 import java.util.LinkedList;

22 import java.util.List;

23 import java.util.Map;

24 import java.util.Set;

import org.eclipse.compare.CompareConfiguration;

import org.eclipse.core.runtime.Assert;

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

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

import org.eclipse.emf.compare.Diff;

import org.eclipse.emf.compare.internal.utils.DiffUtil;

import org.eclipse.emf.compare.rcp.ui.internal.EMFCompareConstants;

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

import org.eclipse.emf.ecore.EObject;

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

import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.TreePath;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.events.MouseMoveListener;

import org.eclipse.swt.events.MouseTrackListener;

import org.eclipse.swt.events.PaintEvent;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Cursor;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Canvas;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.ScrollBar;

import org.eclipse.swt.widgets.Tree;

import org.eclipse.swt.widgets.TreeItem;

59 /**

60 * A specific canvas that must be presented next to a TreeViewer. It shows consequences of a Diff (required

61 * and unmergeable differences), as in the TreeViewer, but in a compact format (small colored rectangles) and

62 * with links to respectives Treeitems.

63 *

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

65 */

66 public class EMFCompareDiffTreeRuler extends Canvas {

68 /** The vertical offset for an annotation. */

69 private static final int Y_OFFSET = 6;

71 /** The height of an annotation. */

72 private static final int ANNOTATION_HEIGHT = 5;

74 /** The TreeViewer associated with this Treeruler. */

75 private final TreeViewer fTreeViewer;

77 /** The color a required diff. */

78 private final Color requiredDiffFillColor;

80 /** The color of an unmergeable diff. **/

81 private final Color unmergeableDiffFillColor;

83 /** The border color a required diff. */

84 private final Color requiredDiffBorderColor;

86 /** The border color an unmergeable diff. */

87 private final Color unmergeableDiffBorderColor;

89 /** The width of this tree ruler. */

90 private final int fWidth;

92 /** The list of required Diff that need to be shown in the TreeRuler. */

93 private Set<Diff> requires;

95 /** The list of unmergeables Diff that need to be shown in the TreeRuler. */

96 private Set<Diff> unmergeables;

98 /** A map that links a diff with tree items. */

        private Multimap<Diff, TreeItem> diffItems;

100

101 /** A map that links a rectangle with a tree item. */

        private Map<Rectangle, TreeItem> annotationsData;

103

104 /** The paint listener. */

105 private PaintListener paintListener;

106

107 /** The mouse click listener. */

108 private MouseListener mouseClickListener;

109

110 /** The mouse move listener. */

111 private MouseMoveListener mouseMoveListener;

112

113 /** The mouse track listener. */

114 private MouseTrackListener mouseTrackListener;

115

116 /** The last cursor used. */

117 private Cursor lastCursor;

118

119 /** The configuration for this control. */

120 private CompareConfiguration fConfiguration;

121

122 /** The selected diff in the Treeviewer associated with this Treeruler. */

123 private Diff selectedDiff;

124

125 /**

126 * Constructor.

127 *

128 * @param parent

129 * the control's parent.

130 * @param style

131 * the style of the control to construct.

132 * @param width

133 * the control's width.

134 * @param treeViewer

135 * the TreeViewer associated with this control.

136 * @param config

137 * the configuration for this control.

138 */

        EMFCompareDiffTreeRuler(Composite parent, int style, int width, TreeViewer treeViewer,

140 CompareConfiguration config) {

141 super(parent, style);

142 fWidth = width;

143 fTreeViewer = treeViewer;

144 fConfiguration = config;

145

                requiredDiffFillColor = JFaceResources.getColorRegistry().get(

147 EMFCompareDiffTreeViewer.REQUIRED_DIFF_COLOR);

                requiredDiffBorderColor = JFaceResources.getColorRegistry().get(

149 EMFCompareDiffTreeViewer.REQUIRED_DIFF_BORDER_COLOR);

                unmergeableDiffFillColor = JFaceResources.getColorRegistry().get(

151 EMFCompareDiffTreeViewer.UNMERGEABLE_DIFF_COLOR);

                unmergeableDiffBorderColor = JFaceResources.getColorRegistry().get(

153 EMFCompareDiffTreeViewer.UNMERGEABLE_DIFF_BORDER_COLOR);

154

155 requires = Sets.newHashSet();

156 unmergeables = Sets.newHashSet();

157 diffItems = HashMultimap.create();

158 annotationsData = Maps.newHashMap();

159

160 paintListener = new PaintListener() {

161 public void paintControl(PaintEvent e) {

162 handlePaintEvent(e);

163 }

164 };

165 addPaintListener(paintListener);

166

167 mouseClickListener = new MouseListener() {

168

169 public void mouseUp(MouseEvent e) {

170 handleMouseClickEvent(e);

171 }

172

173 public void mouseDown(MouseEvent e) {

174 // Do nothing.

175 }

176

177 public void mouseDoubleClick(MouseEvent e) {

178 // Do nothing.

179 }

180 };

181 addMouseListener(mouseClickListener);

182

183 mouseMoveListener = new MouseMoveListener() {

184

185 public void mouseMove(MouseEvent e) {

186 handleMouveMoveEvent(e);

187 }

188 };

189 addMouseMoveListener(mouseMoveListener);

190

191 mouseTrackListener = new MouseTrackListener() {

192

193 public void mouseHover(MouseEvent e) {

194 handleMouseHoverEvent(e);

195 }

196

197 public void mouseExit(MouseEvent e) {

198 // Do nothing.

199 }

200

201 public void mouseEnter(MouseEvent e) {

202 // Do nothing.

203 }

204 };

205 addMouseTrackListener(mouseTrackListener);

206 }

207

208 /**

209 * Compute consequences (required and unmergeable differences) when selection changed occurs.

210 *

211 * @param event

212 * the SelectionChangedEvent event.

213 */

214 public void selectionChanged(SelectionChangedEvent event) {

215 clearAllData();

216 ISelection selection = event.getSelection();

217 if (selection instanceof IStructuredSelection) {

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

219 if (element instanceof Adapter) {

                                Object target = ((Adapter)element).getTarget();

221 if (target instanceof TreeNode) {

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

223 if (data instanceof Diff) {

224 selectedDiff = (Diff)data;

225 computeConsequences();

226 }

227 }

228 }

229 }

230 }

231

232 /**

233 * Compute consequences (required and unmergeable differences).

234 */

235 public void computeConsequences() {

236 clearAllData();

                if (selectedDiff != null) {

                        Boolean leftToRight = (Boolean)fConfiguration.getProperty(EMFCompareConstants.MERGE_WAY);

239 boolean ltr = false;

                        if (leftToRight == null || leftToRight.booleanValue()) {

241 ltr = true;

242 }

                        boolean leftEditable = fConfiguration.isLeftEditable();

                        boolean rightEditable = fConfiguration.isRightEditable();

                        if (ltr || (!ltr && (rightEditable && !leftEditable))) {

                                requires = DiffUtil.getRequires(selectedDiff, true, selectedDiff.getSource());

                                unmergeables = DiffUtil.getUnmergeables(selectedDiff, true);

248 } else {

                                requires = DiffUtil.getRequires(selectedDiff, false, selectedDiff.getSource());

                                unmergeables = DiffUtil.getUnmergeables(selectedDiff, false);

251 }

                        associateTreeItems(Lists.newLinkedList(Iterables.concat(requires, unmergeables)));

253 }

254 }

255

256 /**

257 * Maps tree items with the given list of diffs.

258 *

259 * @param diffs

260 * the given list of diffs.

261 */

        private void associateTreeItems(List<Diff> diffs) {

263 Tree tree = fTreeViewer.getTree();

                for (TreeItem item : tree.getItems()) {

265 associateTreeItem(item, diffs);

266 }

267 }

268

269 /**

270 * Maps, if necessary, the given tree item and all his children with the given list of diffs.

271 *

272 * @param item

273 * the given tree item.

274 * @param diffs

275 * the given list of diffs.

276 */

        private void associateTreeItem(TreeItem item, List<Diff> diffs) {

278 Object data = item.getData();

279 if (data instanceof Adapter) {

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

281 if (target instanceof TreeNode) {

                                EObject treeNodeData = ((TreeNode)target).getData();

                                if (diffs.contains(treeNodeData)) {

                                        diffItems.put((Diff)treeNodeData, item);

285 }

286 }

287 }

                for (TreeItem child : item.getItems()) {

289 associateTreeItem(child, diffs);

290 }

291 }

292

293 /**

294 * Clear all data.

295 */

296 private void clearAllData() {

297 requires.clear();

298 unmergeables.clear();

299 diffItems.clear();

300 annotationsData.clear();

301 }

302

303 /**

304 * Handles the dispose event on this control.

305 */

306 public void handleDispose() {

307 removeMouseTrackListener(mouseTrackListener);

308 removeMouseMoveListener(mouseMoveListener);

309 removeMouseListener(mouseClickListener);

310 removePaintListener(paintListener);

311 }

312

313 /**

314 * Handles the paint event.

315 *

316 * @param e

317 * the paint event.

318 */

319 private void handlePaintEvent(PaintEvent e) {

320 annotationsData.clear();

                Collection<IDifferenceFilter> filters = (Collection<IDifferenceFilter>)fConfiguration

                                .getProperty(EMFCompareConstants.SELECTED_FILTERS);

                Collection<? extends Diff> filteredRequires = filteredDiffs(requires, filters);

                Collection<? extends Diff> filteredUnmergeables = filteredDiffs(unmergeables, filters);

325 for (Diff diff : filteredRequires) {

                        for (TreeItem item : diffItems.get(diff)) {

                                createAnnotation(e, diff, item, requiredDiffFillColor, requiredDiffBorderColor);

328 }

329 }

330 for (Diff diff : filteredUnmergeables) {

                        for (TreeItem item : diffItems.get(diff)) {

                                createAnnotation(e, diff, item, unmergeableDiffFillColor, unmergeableDiffBorderColor);

333 }

334 }

335 }

336

337 /**

338 * Handles the mouse click event.

339 *

340 * @param e

341 * the mouse click event.

342 */

343 private void handleMouseClickEvent(MouseEvent e) {

                for (Rectangle rect : annotationsData.keySet()) {

                        if (e.y >= rect.y && e.y <= rect.y + ANNOTATION_HEIGHT) {

                                TreeItem item = annotationsData.get(rect);

347 TreePath treePath = getTreePathFromItem(item);

                                fTreeViewer.expandToLevel(treePath, 0);

349 fTreeViewer.reveal(treePath);

350 if (isVerticalScrollBarEnabled()) {

                                        TreeItem previousItem = getPreviousItem(item, 2);

                                        fTreeViewer.getTree().setTopItem(previousItem);

353 }

354 redraw();

355 return;

356 }

357 }

358 }

359

360 /**

361 * Handles the mouse move event.

362 *

363 * @param e

364 * the mouse move event.

365 */

366 private void handleMouveMoveEvent(MouseEvent e) {

367 Cursor cursor = null;

                for (Rectangle rect : annotationsData.keySet()) {

                        if (e.y >= rect.y && e.y <= rect.y + ANNOTATION_HEIGHT) {

                                cursor = e.display.getSystemCursor(SWT.CURSOR_HAND);

371 break;

372 }

373 }

374 if (cursor != lastCursor) {

375 setCursor(cursor);

376 lastCursor = cursor;

377 }

378 }

379

380 /**

381 * Handles the mouse hover event.

382 *

383 * @param e

384 * the mouve hover event.

385 */

386 private void handleMouseHoverEvent(MouseEvent e) {

387 String overview = ""; //$NON-NLS-1$

                for (Rectangle rect : annotationsData.keySet()) {

                        if (e.y >= rect.y && e.y <= rect.y + ANNOTATION_HEIGHT) {

                                TreeItem item = annotationsData.get(rect);

391 overview = item.getText();

392 break;

393 }

394 }

395 setToolTipText(overview);

396 }

397

398 /**

399 * Create an annotation in the tree ruler.

400 *

401 * @param e

402 * the PaintEvent.

403 * @param diff

404 * the Diff for which we want to create the annotation.

405 * @param treeItem

406 * the tree item associated with the diff.

407 * @param fill

408 * the annotation's fill color.

409 * @param border

410 * the annotation's border color.

411 */

        private void createAnnotation(PaintEvent e, Diff diff, TreeItem treeItem, Color fill, Color border) {

                TreeItem item = getDeepestVisibleTreeItem(treeItem, treeItem);

                if (item != null) {

                        int y = item.getBounds().y;

                        int yRuler = getSize().y;

417 if (isVerticalScrollBarEnabled()) {

                                int yMin = Math.abs(item.getParent().getItems()[0].getBounds().y);

                                int yMax = getLastVisibleItem().getBounds().y;

420 int realYMax = yMax + yMin;

                                y = (y + yMin) * yRuler / realYMax;

                                if (y + Y_OFFSET + ANNOTATION_HEIGHT > yRuler) {

423 y = yRuler - Y_OFFSET - ANNOTATION_HEIGHT;

424 }

425 }

                        Rectangle rect = drawAnnotation(e.gc, 2, y + Y_OFFSET, fWidth - 5, ANNOTATION_HEIGHT, fill,

427 border);

                        annotationsData.put(rect, treeItem);

429 }

430 }

431

432 /**

433 * Returns the full tree path of the given tree item.

434 *

435 * @param item

436 * the given tree item.

437 * @return the full tree path of the given tree item.

438 */

439 private TreePath getTreePathFromItem(TreeItem item) {

                LinkedList<Object> segments = Lists.newLinkedList();

441 TreeItem parent = item;

                while (parent != null) {

443 Object segment = parent.getData();

444 Assert.isNotNull(segment);

445 segments.addFirst(segment);

446 parent = parent.getParentItem();

447 }

                return new TreePath(segments.toArray());

449 }

450

451 /**

452 * Checks if the vertical scroll bar of the tree viewer associated with this tree ruler is activated and

453 * enabled.

454 *

455 * @return true if the vertical scroll bar is activated and enabled, false otherwise.

456 */

457 private boolean isVerticalScrollBarEnabled() {

                ScrollBar verticalBar = fTreeViewer.getTree().getVerticalBar();

                if (verticalBar != null) {

                        return verticalBar.isVisible() && verticalBar.isEnabled();

461 }

462 return false;

463 }

464

465 /**

466 * Draw an annotation (a Rectangle) on this tree ruler.

467 *

468 * @param gc

469 * the swt GC.

470 * @param x

471 * the x coordinate of the origin of the annotation.

472 * @param y

473 * the y coordinate of the origin of the annotation.

474 * @param w

475 * the width of the annotation.

476 * @param h

477 * the height of the annotation.

478 * @param fill

479 * the annotation's fill color.

480 * @param border

481 * the annotation's border color.

482 * @return the annotation (a Rectangle).

483 */

        private Rectangle drawAnnotation(GC gc, int x, int y, int w, int h, Color fill, Color border) {

                Rectangle rect = new Rectangle(x, y, w, h);

486 gc.setBackground(fill);

487 gc.fillRectangle(rect);

488

489 gc.setForeground(border);

                gc.drawRectangle(x, y, w, h);

491 return rect;

492 }

493

494 /**

495 * Returns, for the given tree item, the deepest visible {@link TreeItem} in the Treeviewer associated

496 * with this TreeRuler.

497 *

498 * @param currentItem

499 * the given tree item.

500 * @param deepestVisibleItem

501 * the deepest visible tree item (a parent or the item itself) of the given item.

502 * @return the deepest visible tree item (a parent or the item itself).

503 */

        private TreeItem getDeepestVisibleTreeItem(final TreeItem currentItem, final TreeItem deepestVisibleItem) {

505 TreeItem item = null;

                if (!currentItem.isDisposed()) {

507 TreeItem parent = currentItem.getParentItem();

                        if (parent == null) {

509 item = deepestVisibleItem;

                        } else if (parent.getExpanded()) {

                                item = getDeepestVisibleTreeItem(parent, deepestVisibleItem);

512 } else {

                                item = getDeepestVisibleTreeItem(parent, parent);

514 }

515 }

516 return item;

517 }

518

519 /**

520 * Get the previous item of the given {@link TreeItem}.

521 *

522 * @param treeItem

523 * the given {@link TreeItem}.

524 * @param index

525 * the index of the previous item.

526 * @return the previous item of the given {@link TreeItem}.

527 */

        private TreeItem getPreviousItem(TreeItem treeItem, int index) {

529 TreeItem previousItem = treeItem;

                if (index > 0) {

531 TreeItem parentItem = treeItem.getParentItem();

                        if (parentItem != null) {

533 int treeItemIndex = 0;

                                for (TreeItem siblingItem : parentItem.getItems()) {

                                        if (siblingItem.equals(treeItem)) {

536 break;

537 }

538 treeItemIndex++;

539 }

                                if (treeItemIndex == 0) {

                                        previousItem = getPreviousItem(parentItem, index - 1);

                                } else if (treeItemIndex == 1) {

                                        TreeItem firstChild = parentItem.getItem(0);

544 previousItem = getLastVisibleItem(firstChild);

                                        previousItem = getPreviousItem(previousItem, index - 1);

546 } else {

                                        previousItem = getPreviousItem(getLastVisibleItem(parentItem.getItem(treeItemIndex - 1)),

548 index - 1);

549 }

550 } else {

551 // It is a root item. May be there are some previous root items.

552 Tree tree = treeItem.getParent();

553 int treeItemIndex = 0;

                                for (TreeItem siblingItem : tree.getItems()) {

                                        if (siblingItem.equals(treeItem)) {

556 break;

557 }

558 treeItemIndex++;

559 }

                                if (treeItemIndex == 0) {

561 previousItem = treeItem;

                                } else if (treeItemIndex == 1) {

                                        TreeItem firstRoot = tree.getItem(0);

                                        if (firstRoot.getExpanded()) {

565 previousItem = getLastVisibleItem(firstRoot);

566 } else {

567 previousItem = firstRoot;

568 }

                                        previousItem = getPreviousItem(previousItem, index - 1);

570 } else {

                                        previousItem = tree.getItem(treeItemIndex - index);

572 }

573 }

574 }

575 return previousItem;

576 }

577

578 /**

579 * Returns the last visible {@link TreeItem} in the Treeviewer associated with this TreeRuler.

580 *

581 * @return the last visible TreeItem in the Treeviewer associated with this TreeRuler.

582 */

583 private TreeItem getLastVisibleItem() {

                int rootChildren = fTreeViewer.getTree().getItemCount();

                return getLastVisibleItem(fTreeViewer.getTree().getItem(rootChildren - 1));

586 }

587

588 /**

589 * Returns the last visible child of the given {@link TreeItem} in the Treeviewer associated with this

590 * TreeRuler.

591 *

592 * @param item

593 * teh given TreeItem.

594 * @return the last visible child of the given TreeItem in the Treeviewer associated with this TreeRuler.

595 */

596 private TreeItem getLastVisibleItem(TreeItem item) {

597 TreeItem lastVisibleItem = null;

                int directChildren = item.getItemCount();

                if (directChildren == 0 || !item.getExpanded()) {

600 lastVisibleItem = item;

601 } else {

                        TreeItem lastDirectChildren = item.getItem(directChildren - 1);

                        if (lastDirectChildren.getData() == null) {

604 lastVisibleItem = item;

                        } else if (lastDirectChildren.getExpanded()) {

606 lastVisibleItem = getLastVisibleItem(lastDirectChildren);

607 } else {

608 lastVisibleItem = lastDirectChildren;

609 }

610 }

611 return lastVisibleItem;

612 }

613

614 /**

615 * From a list of {@link Diff}s, returns the diffs which are not filtered by a filter of the given list of

616 * {@link IDifferenceFilter}.

617 *

618 * @param unfilteredDiffs

619 * the given list of unfiltered diffs.

620 * @param filters

621 * the given list of IDifferenceFilter.

622 * @return A filtered list of diffs.

623 */

        protected Collection<? extends Diff> filteredDiffs(Collection<? extends Diff> unfilteredDiffs,

625 Collection<IDifferenceFilter> filters) {

                if (filters != null) {

                        List<Diff> filteredDiffs = Lists.newArrayList(unfilteredDiffs);

628 for (IDifferenceFilter filter : filters) {

629 for (Diff unfilteredDiff : unfilteredDiffs) {

                                        if (filter.getPredicateWhenSelected().apply(unfilteredDiff)) {

631 filteredDiffs.remove(unfilteredDiff);

632 }

633 }

634 }

635 return filteredDiffs;

636 }

637 return unfilteredDiffs;

638

639 }

640 }