org.spearce.egit.ui/src/org/spearce/egit/ui/internal/GitCompareFileRevisionEditorInput.java

   1 /*******************************************************************************
   2  * Copyright (C) 2007, Robin Rosenberg <robin.rosenberg@dewire.com>
   3  * Copyright (C) 2008, Roger C. Soares <rogersoares@intelinet.com.br>
   4  *
   5  * All rights reserved. This program and the accompanying materials
   6  * are made available under the terms of the Eclipse Public License v1.0
   7  * See LICENSE for the full license text, also available.
   8  *******************************************************************************/
   9 package org.spearce.egit.ui.internal;
  10
  11 import java.lang.reflect.InvocationTargetException;
  12
  13 import org.eclipse.compare.CompareConfiguration;
  14 import org.eclipse.compare.CompareEditorInput;
  15 import org.eclipse.compare.IEditableContent;
  16 import org.eclipse.compare.IResourceProvider;
  17 import org.eclipse.compare.ITypedElement;
  18 import org.eclipse.compare.structuremergeviewer.DiffNode;
  19 import org.eclipse.compare.structuremergeviewer.Differencer;
  20 import org.eclipse.compare.structuremergeviewer.ICompareInput;
  21 import org.eclipse.compare.structuremergeviewer.IDiffElement;
  22 import org.eclipse.compare.structuremergeviewer.IStructureComparator;
  23 import org.eclipse.core.resources.IFile;
  24 import org.eclipse.core.resources.IFileState;
  25 import org.eclipse.core.resources.IResource;
  26 import org.eclipse.core.resources.IStorage;
  27 import org.eclipse.core.runtime.CoreException;
  28 import org.eclipse.core.runtime.IProgressMonitor;
  29 import org.eclipse.core.runtime.NullProgressMonitor;
  30 import org.eclipse.osgi.util.NLS;
  31 import org.eclipse.team.internal.core.history.LocalFileRevision;
  32 import org.eclipse.team.internal.ui.TeamUIMessages;
  33 import org.eclipse.team.internal.ui.TeamUIPlugin;
  34 import org.eclipse.team.internal.ui.Utils;
  35 import org.eclipse.team.internal.ui.history.FileRevisionTypedElement;
  36 import org.eclipse.team.internal.ui.synchronize.LocalResourceTypedElement;
  37 import org.eclipse.ui.IWorkbenchPage;
  38
  39 /**
  40  * The input provider for the compare editor when working on resources
  41  * under Git control.
  42  */
  43 public class GitCompareFileRevisionEditorInput extends CompareEditorInput {
  44
  45         private ITypedElement left;
  46         private ITypedElement right;
  47
  48         /**
  49          * Creates a new CompareFileRevisionEditorInput.
  50          * @param left
  51          * @param right
  52          * @param page
  53          */
  54         public GitCompareFileRevisionEditorInput(ITypedElement left, ITypedElement right, IWorkbenchPage page) {
  55                 super(new CompareConfiguration());
  56                 this.left = left;
  57                 this.right = right;
  58         }
  59
  60         FileRevisionTypedElement getRightRevision() {
  61                 if (right instanceof FileRevisionTypedElement) {
  62                         return (FileRevisionTypedElement) right;
  63                 }
  64                 return null;
  65         }
  66
  67         FileRevisionTypedElement getLeftRevision() {
  68                 if (left instanceof FileRevisionTypedElement) {
  69                         return (FileRevisionTypedElement) left;
  70                 }
  71                 return null;
  72         }
  73
  74         private static void ensureContentsCached(FileRevisionTypedElement left, FileRevisionTypedElement right,
  75                         IProgressMonitor monitor) {
  76                 if (left != null) {
  77                         try {
  78                                 left.cacheContents(monitor);
  79                         } catch (CoreException e) {
  80                                 TeamUIPlugin.log(e);
  81                         }
  82                 }
  83                 if (right != null) {
  84                         try {
  85                                 right.cacheContents(monitor);
  86                         } catch (CoreException e) {
  87                                 TeamUIPlugin.log(e);
  88                         }
  89                 }
  90         }
  91
  92         private boolean isLeftEditable(ICompareInput input) {
  93                 Object left = input.getLeft();
  94                 if (left instanceof IEditableContent) {
  95                         return ((IEditableContent) left).isEditable();
  96                 }
  97                 return false;
  98         }
  99
 100         private IResource getResource(ICompareInput input) {
 101                 if (getLocalElement() != null) {
 102                         return ((IResourceProvider) getLocalElement()).getResource();
 103                 }
 104                 return null;
 105         }
 106
 107         private ICompareInput createCompareInput() {
 108                 return compare(left, right);
 109         }
 110
 111         private DiffNode compare(ITypedElement left, ITypedElement right) {
 112                 if (left.getType().equals(ITypedElement.FOLDER_TYPE)) {
 113                         //                      return new MyDiffContainer(null, left,right);
 114                         DiffNode diffNode = new DiffNode(null,Differencer.CHANGE,null,left,right);
 115                         ITypedElement[] lc = (ITypedElement[])((IStructureComparator)left).getChildren();
 116                         ITypedElement[] rc = (ITypedElement[])((IStructureComparator)right).getChildren();
 117                         int li=0;
 118                         int ri=0;
 119                         while (li<lc.length && ri<rc.length) {
 120                                 ITypedElement ln = lc[li];
 121                                 ITypedElement rn = rc[ri];
 122                                 int compareTo = ln.getName().compareTo(rn.getName());
 123                                 // TODO: Git ordering!
 124                                 if (compareTo == 0) {
 125                                         if (!ln.equals(rn))
 126                                                 diffNode.add(compare(ln,rn));
 127                                         ++li;
 128                                         ++ri;
 129                                 } else if (compareTo < 0) {
 130                                         DiffNode childDiffNode = new DiffNode(Differencer.ADDITION, null, ln, null);
 131                                         diffNode.add(childDiffNode);
 132                                         if (ln.getType().equals(ITypedElement.FOLDER_TYPE)) {
 133                                                 ITypedElement[] children = (ITypedElement[])((IStructureComparator)ln).getChildren();
 134                                                 if(children != null && children.length > 0) {
 135                                                         for (ITypedElement child : children) {
 136                                                                 childDiffNode.add(addDirectoryFiles(child, Differencer.ADDITION));
 137                                                         }
 138                                                 }
 139                                         }
 140                                         ++li;
 141                                 } else {
 142                                         DiffNode childDiffNode = new DiffNode(Differencer.DELETION, null, null, rn);
 143                                         diffNode.add(childDiffNode);
 144                                         if (rn.getType().equals(ITypedElement.FOLDER_TYPE)) {
 145                                                 ITypedElement[] children = (ITypedElement[])((IStructureComparator)rn).getChildren();
 146                                                 if(children != null && children.length > 0) {
 147                                                         for (ITypedElement child : children) {
 148                                                                 childDiffNode.add(addDirectoryFiles(child, Differencer.DELETION));
 149                                                         }
 150                                                 }
 151                                         }
 152                                         ++ri;
 153                                 }
 154                         }
 155                         while (li<lc.length) {
 156                                 ITypedElement ln = lc[li];
 157                                 DiffNode childDiffNode = new DiffNode(Differencer.ADDITION, null, ln, null);
 158                                 diffNode.add(childDiffNode);
 159                                 if (ln.getType().equals(ITypedElement.FOLDER_TYPE)) {
 160                                         ITypedElement[] children = (ITypedElement[])((IStructureComparator)ln).getChildren();
 161                                         if(children != null && children.length > 0) {
 162                                                 for (ITypedElement child : children) {
 163                                                         childDiffNode.add(addDirectoryFiles(child, Differencer.ADDITION));
 164                                                 }
 165                                         }
 166                                 }
 167                                 ++li;
 168                         }
 169                         while (ri<rc.length) {
 170                                 ITypedElement rn = rc[ri];
 171                                 DiffNode childDiffNode = new DiffNode(Differencer.DELETION, null, null, rn);
 172                                 diffNode.add(childDiffNode);
 173                                 if (rn.getType().equals(ITypedElement.FOLDER_TYPE)) {
 174                                         ITypedElement[] children = (ITypedElement[])((IStructureComparator)rn).getChildren();
 175                                         if(children != null && children.length > 0) {
 176                                                 for (ITypedElement child : children) {
 177                                                         childDiffNode.add(addDirectoryFiles(child, Differencer.DELETION));
 178                                                 }
 179                                         }
 180                                 }
 181                                 ++ri;
 182                         }
 183                         return diffNode;
 184                 } else {
 185                         return new DiffNode(left, right);
 186                 }
 187         }
 188
 189         private DiffNode addDirectoryFiles(ITypedElement elem, int diffType) {
 190                 ITypedElement l = null;
 191                 ITypedElement r = null;
 192                 if (diffType == Differencer.DELETION) {
 193                         r = elem;
 194                 } else {
 195                         l = elem;
 196                 }
 197
 198                 if (elem.getType().equals(ITypedElement.FOLDER_TYPE)) {
 199                         DiffNode diffNode = null;
 200                         diffNode = new DiffNode(null,Differencer.CHANGE,null,l,r);
 201                         ITypedElement[] children = (ITypedElement[])((IStructureComparator)elem).getChildren();
 202                         for (ITypedElement child : children) {
 203                                 diffNode.add(addDirectoryFiles(child, diffType));
 204                         }
 205                         return diffNode;
 206                 } else {
 207                         return new DiffNode(diffType, null, l, r);
 208                 }
 209         }
 210
 211         private void initLabels(ICompareInput input) {
 212                 CompareConfiguration cc = getCompareConfiguration();
 213                 if(left != null && left instanceof GitResourceNode) {
 214                         String ci = ((GitResourceNode)left).getContentIdentifier();
 215                         if(ci != null) {
 216                                 cc.setLeftLabel(ci.substring(0, 7) + "..");
 217                         }
 218                 }
 219                 if(right != null && right instanceof GitResourceNode) {
 220                         String ci = ((GitResourceNode)right).getContentIdentifier();
 221                         if(ci != null) {
 222                                 cc.setRightLabel(ci.substring(0, 7) + "..");
 223                         }
 224                 }
 225                 if (getLeftRevision() != null) {
 226                         String leftLabel = getFileRevisionLabel(getLeftRevision());
 227                         cc.setLeftLabel(leftLabel);
 228                 } else if (getResource(input) != null) {
 229                         String label = NLS.bind(TeamUIMessages.CompareFileRevisionEditorInput_workspace, new Object[]{ input.getLeft().getName() });
 230                         cc.setLeftLabel(label);
 231                 }
 232                 if (getRightRevision() != null) {
 233                         String rightLabel = getFileRevisionLabel(getRightRevision());
 234                         cc.setRightLabel(rightLabel);
 235                 }
 236         }
 237
 238         private String getFileRevisionLabel(FileRevisionTypedElement element) {
 239                 Object fileObject = element.getFileRevision();
 240                 if (fileObject instanceof LocalFileRevision){
 241                         return NLS.bind(TeamUIMessages.CompareFileRevisionEditorInput_localRevision, new Object[]{element.getName(), element.getTimestamp()});
 242                 } else {
 243                         return NLS.bind(TeamUIMessages.CompareFileRevisionEditorInput_repository, new Object[]{ element.getName(), element.getContentIdentifier()});
 244                 }
 245         }
 246
 247         /* (non-Javadoc)
 248          * @see org.eclipse.compare.CompareEditorInput#getToolTipText()
 249          */
 250         public String getToolTipText() {
 251                 Object[] titleObject = new Object[3];
 252                 titleObject[0] = getLongName(left);
 253                 titleObject[1] = getContentIdentifier(getLeftRevision());
 254                 titleObject[2] = getContentIdentifier(getRightRevision());
 255                 return NLS.bind(TeamUIMessages.CompareFileRevisionEditorInput_compareResourceAndVersions, titleObject);
 256         }
 257
 258         /* (non-Javadoc)
 259          * @see org.eclipse.compare.CompareEditorInput#getTitle()
 260          */
 261         public String getTitle() {
 262                 Object[] titleObject = new Object[3];
 263                 titleObject[0] = getShortName(left);
 264                 titleObject[1] = getContentIdentifier(getLeftRevision());
 265                 titleObject[2] = getContentIdentifier(getRightRevision());
 266                 return NLS.bind(TeamUIMessages.CompareFileRevisionEditorInput_compareResourceAndVersions, titleObject);
 267         }
 268
 269         /* (non-Javadoc)
 270          * @see org.eclipse.compare.CompareEditorInput#getAdapter(java.lang.Class)
 271          */
 272         public Object getAdapter(Class adapter) {
 273                 if (adapter == IFile.class || adapter == IResource.class) {
 274                         if (getLocalElement() != null) {
 275                                 return getLocalElement().getResource();
 276                         }
 277                         return null;
 278                 }
 279                 return super.getAdapter(adapter);
 280         }
 281
 282         private String getShortName(ITypedElement element) {
 283                 if (element instanceof FileRevisionTypedElement){
 284                         FileRevisionTypedElement fileRevisionElement = (FileRevisionTypedElement) element;
 285                         return fileRevisionElement.getName();
 286                 }
 287                 else if (element instanceof LocalResourceTypedElement){
 288                         LocalResourceTypedElement typedContent = (LocalResourceTypedElement) element;
 289                         return typedContent.getResource().getName();
 290                 }
 291                 return element.getName();
 292         }
 293
 294         private String getLongName(ITypedElement element) {
 295                 if (element instanceof FileRevisionTypedElement){
 296                         FileRevisionTypedElement fileRevisionElement = (FileRevisionTypedElement) element;
 297                         return fileRevisionElement.getPath();
 298                 }
 299                 else if (element instanceof LocalResourceTypedElement){
 300                         LocalResourceTypedElement typedContent = (LocalResourceTypedElement) element;
 301                         return typedContent.getResource().getFullPath().toString();
 302                 }
 303                 return element.getName();
 304         }
 305
 306         private String getContentIdentifier(ITypedElement element){
 307                 if (element instanceof FileRevisionTypedElement){
 308                         FileRevisionTypedElement fileRevisionElement = (FileRevisionTypedElement) element;
 309                         Object fileObject = fileRevisionElement.getFileRevision();
 310                         if (fileObject instanceof LocalFileRevision){
 311                                 try {
 312                                         IStorage storage = ((LocalFileRevision) fileObject).getStorage(new NullProgressMonitor());
 313                                         if (Utils.getAdapter(storage, IFileState.class) != null){
 314                                                 //local revision
 315                                                 return TeamUIMessages.CompareFileRevisionEditorInput_0;
 316                                         } else if (Utils.getAdapter(storage, IFile.class) != null) {
 317                                                 //current revision
 318                                                 return TeamUIMessages.CompareFileRevisionEditorInput_1;
 319                                         }
 320                                 } catch (CoreException e) {
 321                                 }
 322                         } else {
 323                                 return fileRevisionElement.getContentIdentifier();
 324                         }
 325                 }
 326                 return TeamUIMessages.CompareFileRevisionEditorInput_2;
 327         }
 328
 329 //      /* (non-Javadoc)
 330 //       * @see org.eclipse.team.ui.synchronize.LocalResourceCompareEditorInput#fireInputChange()
 331 //       */
 332 //      protected void fireInputChange() {
 333 //              ((DiffNode)getCompareResult()).fireChange();
 334 //      }
 335 //
 336 //      /* (non-Javadoc)
 337 //       * @see org.eclipse.team.ui.synchronize.SaveableCompareEditorInput#contentsCreated()
 338 //       */
 339 //      protected void contentsCreated() {
 340 //              super.contentsCreated();
 341 //              notifier.initialize();
 342 //      }
 343 //
 344 //      /* (non-Javadoc)
 345 //       * @see org.eclipse.team.ui.synchronize.SaveableCompareEditorInput#handleDispose()
 346 //       */
 347 //      protected void handleDispose() {
 348 //              super.handleDispose();
 349 //              notifier.dispose();
 350 //              if (getLocalElement() != null) {
 351 //                      getLocalElement().discardBuffer();
 352 //              }
 353 //      }
 354 //
 355         private LocalResourceTypedElement getLocalElement() {
 356                 if (left instanceof LocalResourceTypedElement) {
 357                         return (LocalResourceTypedElement) left;
 358                 }
 359                 return null;
 360         }
 361
 362         protected Object prepareInput(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
 363                 ICompareInput input = createCompareInput();
 364                 getCompareConfiguration().setLeftEditable(isLeftEditable(input));
 365                 getCompareConfiguration().setRightEditable(false);
 366                 ensureContentsCached(getLeftRevision(), getRightRevision(), monitor);
 367                 initLabels(input);
 368                 setTitle(NLS.bind(TeamUIMessages.SyncInfoCompareInput_title, new String[] { input.getName() }));
 369
 370                 // The compare editor (Structure Compare) will show the diff filenames
 371                 // with their project relative path. So, no need to also show directory entries.
 372                 DiffNode flatDiffNode = new DiffNode(null,Differencer.CHANGE,null,left,right);
 373                 flatDiffView(flatDiffNode, (DiffNode) input);
 374
 375                 return flatDiffNode;
 376         }
 377
 378         private void flatDiffView(DiffNode rootNode, DiffNode currentNode) {
 379                 if(currentNode != null) {
 380                         IDiffElement[] dElems = currentNode.getChildren();
 381                         if(dElems != null) {
 382                                 for(IDiffElement dElem : dElems) {
 383                                         DiffNode dNode = (DiffNode) dElem;
 384                                         if(dNode.getChildren() != null && dNode.getChildren().length > 0) {
 385                                                 flatDiffView(rootNode, dNode);
 386                                         } else {
 387                                                 rootNode.add(dNode);
 388                                         }
 389                                 }
 390                         }
 391                 }
 392         }
 393
 394 }