org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/repository/RepositoriesView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010 SAP AG.
   3  * All rights reserved. This program and the accompanying materials
   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  *    Mathias Kinzler (SAP AG) - initial implementation
  10  *******************************************************************************/
  11 package org.eclipse.egit.ui.internal.repository;
  12
  13 import java.io.File;
  14 import java.io.IOException;
  15 import java.util.ArrayList;
  16 import java.util.Collection;
  17 import java.util.Collections;
  18 import java.util.Comparator;
  19 import java.util.HashSet;
  20 import java.util.List;
  21 import java.util.Set;
  22 import java.util.StringTokenizer;
  23 import java.util.TreeSet;
  24
  25 import org.eclipse.core.resources.IProject;
  26 import org.eclipse.core.resources.IProjectDescription;
  27 import org.eclipse.core.resources.IWorkspace;
  28 import org.eclipse.core.resources.IWorkspaceRunnable;
  29 import org.eclipse.core.resources.ResourcesPlugin;
  30 import org.eclipse.core.runtime.CoreException;
  31 import org.eclipse.core.runtime.IPath;
  32 import org.eclipse.core.runtime.IProgressMonitor;
  33 import org.eclipse.core.runtime.IStatus;
  34 import org.eclipse.core.runtime.NullProgressMonitor;
  35 import org.eclipse.core.runtime.Path;
  36 import org.eclipse.core.runtime.Status;
  37 import org.eclipse.core.runtime.SubProgressMonitor;
  38 import org.eclipse.core.runtime.jobs.Job;
  39 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
  40 import org.eclipse.core.runtime.preferences.InstanceScope;
  41 import org.eclipse.egit.core.op.BranchOperation;
  42 import org.eclipse.egit.core.op.ConnectProviderOperation;
  43 import org.eclipse.egit.ui.Activator;
  44 import org.eclipse.egit.ui.internal.clone.GitCloneWizard;
  45 import org.eclipse.egit.ui.internal.clone.GitProjectsImportPage;
  46 import org.eclipse.jface.action.Action;
  47 import org.eclipse.jface.action.IAction;
  48 import org.eclipse.jface.dialogs.MessageDialog;
  49 import org.eclipse.jface.layout.GridDataFactory;
  50 import org.eclipse.jface.resource.CompositeImageDescriptor;
  51 import org.eclipse.jface.resource.ImageDescriptor;
  52 import org.eclipse.jface.text.DefaultInformationControl;
  53 import org.eclipse.jface.text.TextPresentation;
  54 import org.eclipse.jface.text.DefaultInformationControl.IInformationPresenter;
  55 import org.eclipse.jface.viewers.BaseLabelProvider;
  56 import org.eclipse.jface.viewers.IStructuredSelection;
  57 import org.eclipse.jface.viewers.ITableLabelProvider;
  58 import org.eclipse.jface.viewers.ITreeContentProvider;
  59 import org.eclipse.jface.viewers.TreeViewer;
  60 import org.eclipse.jface.viewers.Viewer;
  61 import org.eclipse.jface.viewers.ViewerCell;
  62 import org.eclipse.jface.window.Window;
  63 import org.eclipse.jface.wizard.Wizard;
  64 import org.eclipse.jface.wizard.WizardDialog;
  65 import org.eclipse.jgit.lib.Constants;
  66 import org.eclipse.jgit.lib.Ref;
  67 import org.eclipse.jgit.lib.Repository;
  68 import org.eclipse.jgit.lib.RepositoryCache;
  69 import org.eclipse.osgi.util.NLS;
  70 import org.eclipse.swt.SWT;
  71 import org.eclipse.swt.events.MenuDetectEvent;
  72 import org.eclipse.swt.events.MenuDetectListener;
  73 import org.eclipse.swt.events.MouseEvent;
  74 import org.eclipse.swt.events.MouseMoveListener;
  75 import org.eclipse.swt.events.MouseTrackAdapter;
  76 import org.eclipse.swt.events.SelectionAdapter;
  77 import org.eclipse.swt.events.SelectionEvent;
  78 import org.eclipse.swt.graphics.GC;
  79 import org.eclipse.swt.graphics.Image;
  80 import org.eclipse.swt.graphics.Point;
  81 import org.eclipse.swt.layout.GridLayout;
  82 import org.eclipse.swt.widgets.Composite;
  83 import org.eclipse.swt.widgets.Display;
  84 import org.eclipse.swt.widgets.Menu;
  85 import org.eclipse.swt.widgets.MenuItem;
  86 import org.eclipse.swt.widgets.Tree;
  87 import org.eclipse.swt.widgets.TreeColumn;
  88 import org.eclipse.swt.widgets.TreeItem;
  89 import org.eclipse.ui.ISharedImages;
  90 import org.eclipse.ui.PlatformUI;
  91 import org.eclipse.ui.ide.IDE.SharedImages;
  92 import org.eclipse.ui.part.ViewPart;
  93 import org.eclipse.ui.progress.IWorkbenchSiteProgressService;
  94 import org.eclipse.ui.statushandlers.StatusManager;
  95 import org.eclipse.ui.wizards.datatransfer.ExternalProjectImportWizard;
  96 import org.osgi.service.prefs.BackingStoreException;
  97
  98 /**
  99  *
 100  * The Git Repositories view.
 101  * <p>
 102  * This keeps track of a bunch of local directory names each of which represent
 103  * a Git Repository. This list is stored in some Preferences object and used to
 104  * build the tree in the view.
 105  * <p>
 106  * TODO
 107  * <li>Icons</li>
 108  * <li>String externalization</li>
 109  * <li>Clarification whether to show projects, perhaps configurable switch</li>
 110  *
 111  */
 112 public class RepositoriesView extends ViewPart {
 113
 114         private static final String PREFS_DIRECTORIES = "GitRepositoriesView.GitDirectories"; //$NON-NLS-1$
 115
 116         private static final ImageDescriptor CHECKEDOUT_OVERLAY = Activator
 117                         .getDefault().getImageRegistry().getDescriptor(
 118                                         Activator.ICON_CHECKEDOUT_OVR);
 119
 120         private Job scheduledJob;
 121
 122         private TreeViewer tv;
 123
 124         private IAction importAction;
 125
 126         private IAction addAction;
 127
 128         private IAction refreshAction;
 129
 130         enum RepositoryTreeNodeType {
 131
 132                 REPO(Activator.ICON_REPOSITORY), REF(PlatformUI.getWorkbench()
 133                                 .getSharedImages().getImage(ISharedImages.IMG_OBJ_FOLDER)), PROJ(
 134                                 PlatformUI.getWorkbench().getSharedImages().getImage(
 135                                                 SharedImages.IMG_OBJ_PROJECT_CLOSED)), BRANCHES(
 136                                 Activator.ICON_BRANCHES), PROJECTS(PlatformUI.getWorkbench()
 137                                 .getSharedImages().getImage(ISharedImages.IMG_OBJ_FOLDER));
 138
 139                 private final Image myImage;
 140
 141                 private RepositoryTreeNodeType(String iconName) {
 142
 143                         if (iconName != null) {
 144                                 myImage = Activator.getDefault().getImageRegistry().get(
 145                                                 iconName);
 146                         } else {
 147                                 myImage = null;
 148                         }
 149
 150                 }
 151
 152                 private RepositoryTreeNodeType(Image icon) {
 153                         myImage = icon;
 154
 155                 }
 156
 157                 public Image getIcon() {
 158                         return myImage;
 159                 }
 160
 161         }
 162
 163         private static final class RepositoryTreeNode<T> {
 164
 165                 private final Repository myRepository;
 166
 167                 private final T myObject;
 168
 169                 private final RepositoryTreeNodeType myType;
 170
 171                 private final RepositoryTreeNode myParent;
 172
 173                 private String branch;
 174
 175                 public RepositoryTreeNode(RepositoryTreeNode parent,
 176                                 RepositoryTreeNodeType type, Repository repository, T treeObject) {
 177                         myParent = parent;
 178                         myRepository = repository;
 179                         myType = type;
 180                         myObject = treeObject;
 181                 }
 182
 183                 @SuppressWarnings("unchecked")
 184                 private RepositoryTreeNode<Repository> getRepositoryNode() {
 185                         if (myType == RepositoryTreeNodeType.REPO) {
 186                                 return (RepositoryTreeNode<Repository>) this;
 187                         } else {
 188                                 return getParent().getRepositoryNode();
 189                         }
 190                 }
 191
 192                 /**
 193                  * We keep this cached in the repository node to avoid repeated lookups
 194                  *
 195                  * @return the full branch
 196                  * @throws IOException
 197                  */
 198                 public String getBranch() throws IOException {
 199                         if (myType != RepositoryTreeNodeType.REPO) {
 200                                 return getRepositoryNode().getBranch();
 201                         }
 202                         if (branch == null) {
 203                                 branch = getRepository().getBranch();
 204                         }
 205                         return branch;
 206                 }
 207
 208                 public RepositoryTreeNode getParent() {
 209                         return myParent;
 210                 }
 211
 212                 public RepositoryTreeNodeType getType() {
 213                         return myType;
 214                 }
 215
 216                 public Repository getRepository() {
 217                         return myRepository;
 218                 }
 219
 220                 public T getObject() {
 221                         return myObject;
 222                 }
 223
 224                 @Override
 225                 public int hashCode() {
 226                         final int prime = 31;
 227                         int result = 1;
 228                         switch (myType) {
 229                         case REPO:
 230                         case PROJECTS:
 231                         case BRANCHES:
 232                                 result = prime
 233                                                 * result
 234                                                 + ((myObject == null) ? 0 : ((Repository) myObject)
 235                                                                 .getDirectory().hashCode());
 236                                 break;
 237                         case REF:
 238                                 result = prime
 239                                                 * result
 240                                                 + ((myObject == null) ? 0 : ((Ref) myObject).getName()
 241                                                                 .hashCode());
 242                                 break;
 243                         case PROJ:
 244                                 result = prime
 245                                                 * result
 246                                                 + ((myObject == null) ? 0 : ((File) myObject).getPath()
 247                                                                 .hashCode());
 248                                 break;
 249
 250                         default:
 251                                 break;
 252                         }
 253
 254                         result = prime * result
 255                                         + ((myParent == null) ? 0 : myParent.hashCode());
 256                         result = prime
 257                                         * result
 258                                         + ((myRepository == null) ? 0 : myRepository.getDirectory()
 259                                                         .hashCode());
 260                         result = prime * result
 261                                         + ((myType == null) ? 0 : myType.hashCode());
 262                         return result;
 263                 }
 264
 265                 @Override
 266                 public boolean equals(Object obj) {
 267                         if (this == obj)
 268                                 return true;
 269                         if (obj == null)
 270                                 return false;
 271                         if (getClass() != obj.getClass())
 272                                 return false;
 273
 274                         RepositoryTreeNode other = (RepositoryTreeNode) obj;
 275
 276                         if (myType == null) {
 277                                 if (other.myType != null)
 278                                         return false;
 279                         } else if (!myType.equals(other.myType))
 280                                 return false;
 281                         if (myParent == null) {
 282                                 if (other.myParent != null)
 283                                         return false;
 284                         } else if (!myParent.equals(other.myParent))
 285                                 return false;
 286                         if (myRepository == null) {
 287                                 if (other.myRepository != null)
 288                                         return false;
 289                         } else if (!myRepository.getDirectory().equals(
 290                                         other.myRepository.getDirectory()))
 291                                 return false;
 292                         if (myObject == null) {
 293                                 if (other.myObject != null)
 294                                         return false;
 295                         } else if (!checkObjectsEqual(other.myObject))
 296                                 return false;
 297
 298                         return true;
 299                 }
 300
 301                 private boolean checkObjectsEqual(Object otherObject) {
 302                         switch (myType) {
 303                         case REPO:
 304                         case PROJECTS:
 305                         case BRANCHES:
 306                                 return ((Repository) myObject).getDirectory().equals(
 307                                                 ((Repository) otherObject).getDirectory());
 308                         case REF:
 309                                 return ((Ref) myObject).getName().equals(
 310                                                 ((Ref) otherObject).getName());
 311                         case PROJ:
 312                                 return ((File) myObject).getPath().equals(
 313                                                 ((File) otherObject).getPath());
 314                         default:
 315                                 return false;
 316                         }
 317                 }
 318         }
 319
 320         private static final class ContentProvider implements ITreeContentProvider {
 321
 322                 @SuppressWarnings("unchecked")
 323                 public Object[] getElements(Object inputElement) {
 324
 325                         Comparator<RepositoryTreeNode<Repository>> sorter = new Comparator<RepositoryTreeNode<Repository>>() {
 326
 327                                 public int compare(RepositoryTreeNode<Repository> o1,
 328                                                 RepositoryTreeNode<Repository> o2) {
 329                                         return getRepositoryName(o1.getObject()).compareTo(
 330                                                         getRepositoryName(o2.getObject()));
 331                                 }
 332
 333                         };
 334
 335                         Set<RepositoryTreeNode<Repository>> output = new TreeSet<RepositoryTreeNode<Repository>>(
 336                                         sorter);
 337
 338                         for (Repository repo : ((List<Repository>) inputElement)) {
 339                                 output.add(new RepositoryTreeNode<Repository>(null,
 340                                                 RepositoryTreeNodeType.REPO, repo, repo));
 341                         }
 342
 343                         return output.toArray();
 344                 }
 345
 346                 public void dispose() {
 347                         // nothing
 348                 }
 349
 350                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 351                         // nothing
 352                 }
 353
 354                 public Object[] getChildren(Object parentElement) {
 355
 356                         RepositoryTreeNode node = (RepositoryTreeNode) parentElement;
 357                         Repository repo = node.getRepository();
 358
 359                         switch (node.getType()) {
 360
 361                         case BRANCHES:
 362
 363                                 List<RepositoryTreeNode<Ref>> refs = new ArrayList<RepositoryTreeNode<Ref>>();
 364
 365                                 Repository rep = node.getRepository();
 366                                 for (Ref ref : rep.getAllRefs().values()) {
 367                                         refs.add(new RepositoryTreeNode<Ref>(node,
 368                                                         RepositoryTreeNodeType.REF, repo, ref));
 369                                 }
 370
 371                                 return refs.toArray();
 372
 373                         case REPO:
 374
 375                                 List<RepositoryTreeNode<Repository>> branches = new ArrayList<RepositoryTreeNode<Repository>>();
 376
 377                                 branches.add(new RepositoryTreeNode<Repository>(node,
 378                                                 RepositoryTreeNodeType.BRANCHES, node.getRepository(),
 379                                                 node.getRepository()));
 380
 381                                 branches.add(new RepositoryTreeNode<Repository>(node,
 382                                                 RepositoryTreeNodeType.PROJECTS, node.getRepository(),
 383                                                 node.getRepository()));
 384
 385                                 return branches.toArray();
 386
 387                         case PROJECTS:
 388
 389                                 List<RepositoryTreeNode<File>> projects = new ArrayList<RepositoryTreeNode<File>>();
 390
 391                                 // TODO do we want to show the projects here?
 392                                 Collection<File> result = new HashSet<File>();
 393                                 Set<String> traversed = new HashSet<String>();
 394                                 collectProjectFilesFromDirectory(result, repo.getDirectory()
 395                                                 .getParentFile(), traversed, new NullProgressMonitor());
 396                                 for (File file : result) {
 397                                         projects.add(new RepositoryTreeNode<File>(node,
 398                                                         RepositoryTreeNodeType.PROJ, repo, file));
 399                                 }
 400
 401                                 Comparator<RepositoryTreeNode<File>> sorter = new Comparator<RepositoryTreeNode<File>>() {
 402
 403                                         public int compare(RepositoryTreeNode<File> o1,
 404                                                         RepositoryTreeNode<File> o2) {
 405                                                 return o1.getObject().getName().compareTo(
 406                                                                 o2.getObject().getName());
 407                                         }
 408                                 };
 409                                 Collections.sort(projects, sorter);
 410
 411                                 return projects.toArray();
 412
 413                         default:
 414                                 return null;
 415                         }
 416
 417                 }
 418
 419                 public Object getParent(Object element) {
 420
 421                         return ((RepositoryTreeNode) element).getParent();
 422                 }
 423
 424                 public boolean hasChildren(Object element) {
 425                         Object[] children = getChildren(element);
 426                         return children != null && children.length > 0;
 427                 }
 428
 429                 private boolean collectProjectFilesFromDirectory(
 430                                 Collection<File> files, File directory,
 431                                 Set<String> directoriesVisited, IProgressMonitor monitor) {
 432
 433                         // stolen from the GitCloneWizard; perhaps we should completely drop
 434                         // the projects from this view, though
 435                         if (monitor.isCanceled()) {
 436                                 return false;
 437                         }
 438                         monitor.subTask(NLS.bind(
 439                                         RepositoryViewUITexts.RepositoriesView_Checking_Message,
 440                                         directory.getPath()));
 441                         File[] contents = directory.listFiles();
 442                         if (contents == null)
 443                                 return false;
 444
 445                         // first look for project description files
 446                         final String dotProject = IProjectDescription.DESCRIPTION_FILE_NAME;
 447                         for (int i = 0; i < contents.length; i++) {
 448                                 File file = contents[i];
 449                                 if (file.isFile() && file.getName().equals(dotProject)) {
 450                                         files.add(file.getParentFile());
 451                                         // don't search sub-directories since we can't have nested
 452                                         // projects
 453                                         return true;
 454                                 }
 455                         }
 456                         // no project description found, so recurse into sub-directories
 457                         for (int i = 0; i < contents.length; i++) {
 458                                 if (contents[i].isDirectory()) {
 459                                         if (!contents[i].getName().equals(
 460                                                         GitProjectsImportPage.METADATA_FOLDER)) {
 461                                                 try {
 462                                                         String canonicalPath = contents[i]
 463                                                                         .getCanonicalPath();
 464                                                         if (!directoriesVisited.add(canonicalPath)) {
 465                                                                 // already been here --> do not recurse
 466                                                                 continue;
 467                                                         }
 468                                                 } catch (IOException exception) {
 469                                                         StatusManager.getManager().handle(
 470                                                                         new Status(IStatus.ERROR, Activator
 471                                                                                         .getPluginId(), exception
 472                                                                                         .getLocalizedMessage(), exception));
 473
 474                                                 }
 475                                                 collectProjectFilesFromDirectory(files, contents[i],
 476                                                                 directoriesVisited, monitor);
 477                                         }
 478                                 }
 479                         }
 480                         return true;
 481                 }
 482
 483         }
 484
 485         private static final class LabelProvider extends BaseLabelProvider
 486                         implements ITableLabelProvider {
 487
 488                 private DefaultInformationControl infoControl;
 489
 490                 /**
 491                  *
 492                  * @param viewer
 493                  */
 494                 LabelProvider(final TreeViewer viewer) {
 495
 496                         viewer.setLabelProvider(this);
 497                         Tree tree = viewer.getTree();
 498                         TreeColumn col = new TreeColumn(tree, SWT.NONE);
 499                         col.setWidth(400);
 500                         viewer.getTree().addMouseTrackListener(new MouseTrackAdapter() {
 501
 502                                 @Override
 503                                 public void mouseHover(MouseEvent e) {
 504
 505                                         Point eventPoint = new Point(e.x, e.y);
 506
 507                                         TreeItem item = viewer.getTree().getItem(eventPoint);
 508                                         if (item != null) {
 509
 510                                                 RepositoryTreeNode node = (RepositoryTreeNode) item
 511                                                                 .getData();
 512                                                 String text = node.getRepository().getDirectory()
 513                                                                 .getAbsolutePath();
 514
 515                                                 final ViewerCell cell = viewer.getCell(eventPoint);
 516
 517                                                 if (infoControl != null && infoControl.isVisible()) {
 518                                                         infoControl.setVisible(false);
 519                                                 }
 520
 521                                                 GC testGc = new GC(cell.getControl());
 522                                                 final Point textExtent = testGc.textExtent(text);
 523                                                 testGc.dispose();
 524
 525                                                 if (infoControl == null || !infoControl.isVisible()) {
 526
 527                                                         IInformationPresenter ips = new IInformationPresenter() {
 528
 529                                                                 public String updatePresentation(
 530                                                                                 Display display, String hoverInfo,
 531                                                                                 TextPresentation presentation,
 532                                                                                 int maxWidth, int maxHeight) {
 533                                                                         return hoverInfo;
 534                                                                 }
 535
 536                                                         };
 537
 538                                                         infoControl = new DefaultInformationControl(Display
 539                                                                         .getCurrent().getActiveShell().getShell(),
 540                                                                         ips) {
 541
 542                                                                 @Override
 543                                                                 public void setInformation(String content) {
 544                                                                         super.setInformation(content);
 545                                                                         super.setSize(textExtent.x, textExtent.y);
 546                                                                 }
 547
 548                                                         };
 549                                                 }
 550
 551                                                 Point dispPoint = viewer.getControl().toDisplay(
 552                                                                 eventPoint);
 553
 554                                                 infoControl.setLocation(dispPoint);
 555
 556                                                 // the default info provider works better with \r ...
 557                                                 infoControl.setInformation(text);
 558
 559                                                 final MouseMoveListener moveListener = new MouseMoveListener() {
 560
 561                                                         public void mouseMove(MouseEvent evt) {
 562                                                                 infoControl.setVisible(false);
 563                                                                 cell.getControl().removeMouseMoveListener(this);
 564
 565                                                         }
 566                                                 };
 567
 568                                                 cell.getControl().addMouseMoveListener(moveListener);
 569
 570                                                 infoControl.setVisible(true);
 571
 572                                         }
 573
 574                                 }
 575
 576                         });
 577
 578                 }
 579
 580                 public Image getColumnImage(Object element, int columnIndex) {
 581                         return decorateImage(((RepositoryTreeNode) element).getType()
 582                                         .getIcon(), element);
 583                 }
 584
 585                 public String getColumnText(Object element, int columnIndex) {
 586
 587                         RepositoryTreeNode node = (RepositoryTreeNode) element;
 588                         switch (node.getType()) {
 589                         case REPO:
 590                                 File directory = ((Repository) node.getObject()).getDirectory()
 591                                                 .getParentFile();
 592                                 return (directory.getName() + " - " + directory //$NON-NLS-1$
 593                                                 .getAbsolutePath());
 594                         case BRANCHES:
 595                                 return RepositoryViewUITexts.RepositoriesView_Branches_Nodetext;
 596                         case PROJECTS:
 597                                 return RepositoryViewUITexts.RepositoriesView_ExistingProjects_Nodetext;
 598                         case REF:
 599                                 Ref ref = (Ref) node.getObject();
 600                                 // shorten the name
 601                                 String refName = node.getRepository().shortenRefName(
 602                                                 ref.getName());
 603                                 if (ref.isSymbolic()) {
 604                                         refName = refName
 605                                                         + " - " //$NON-NLS-1$
 606                                                         + node.getRepository().shortenRefName(
 607                                                                         ref.getLeaf().getName());
 608                                 }
 609                                 return refName;
 610                         case PROJ:
 611
 612                                 File file = (File) node.getObject();
 613                                 return file.getName();
 614
 615                         default:
 616                                 return null;
 617                         }
 618                 }
 619
 620                 public Image decorateImage(final Image image, Object element) {
 621
 622                         RepositoryTreeNode node = (RepositoryTreeNode) element;
 623                         switch (node.getType()) {
 624
 625                         case REF:
 626                                 Ref ref = (Ref) node.getObject();
 627                                 // shorten the name
 628                                 String refName = node.getRepository().shortenRefName(
 629                                                 ref.getName());
 630                                 try {
 631                                         String branch = node.getBranch();
 632                                         if (refName.equals(branch)) {
 633                                                 CompositeImageDescriptor cd = new CompositeImageDescriptor() {
 634
 635                                                         @Override
 636                                                         protected Point getSize() {
 637                                                                 return new Point(image.getBounds().width, image
 638                                                                                 .getBounds().width);
 639                                                         }
 640
 641                                                         @Override
 642                                                         protected void drawCompositeImage(int width,
 643                                                                         int height) {
 644                                                                 drawImage(image.getImageData(), 0, 0);
 645                                                                 drawImage(CHECKEDOUT_OVERLAY.getImageData(), 0,
 646                                                                                 0);
 647
 648                                                         }
 649                                                 };
 650                                                 return cd.createImage();
 651                                         }
 652                                 } catch (IOException e1) {
 653                                         // simply ignore here
 654                                 }
 655                                 return image;
 656
 657                         case PROJ:
 658
 659                                 File file = (File) node.getObject();
 660
 661                                 for (IProject proj : ResourcesPlugin.getWorkspace().getRoot()
 662                                                 .getProjects()) {
 663                                         if (proj.getLocation().equals(
 664                                                         new Path(file.getAbsolutePath()))) {
 665                                                 CompositeImageDescriptor cd = new CompositeImageDescriptor() {
 666
 667                                                         @Override
 668                                                         protected Point getSize() {
 669                                                                 return new Point(image.getBounds().width, image
 670                                                                                 .getBounds().width);
 671                                                         }
 672
 673                                                         @Override
 674                                                         protected void drawCompositeImage(int width,
 675                                                                         int height) {
 676                                                                 drawImage(image.getImageData(), 0, 0);
 677                                                                 drawImage(CHECKEDOUT_OVERLAY.getImageData(), 0,
 678                                                                                 0);
 679
 680                                                         }
 681                                                 };
 682                                                 return cd.createImage();
 683                                         }
 684                                 }
 685                                 return image;
 686
 687                         default:
 688                                 return image;
 689                         }
 690                 }
 691
 692         }
 693
 694         private List<String> getGitDirs() {
 695                 List<String> resultStrings = new ArrayList<String>();
 696                 String dirs = new InstanceScope().getNode(Activator.getPluginId()).get(
 697                                 PREFS_DIRECTORIES, ""); //$NON-NLS-1$
 698                 if (dirs != null && dirs.length() > 0) {
 699                         StringTokenizer tok = new StringTokenizer(dirs, File.pathSeparator);
 700                         while (tok.hasMoreTokens()) {
 701                                 String dirName = tok.nextToken();
 702                                 File testFile = new File(dirName);
 703                                 if (testFile.exists()) {
 704                                         resultStrings.add(dirName);
 705                                 }
 706                         }
 707                 }
 708                 Collections.sort(resultStrings);
 709                 return resultStrings;
 710         }
 711
 712         private void removeDir(String dir) {
 713
 714                 IEclipsePreferences prefs = new InstanceScope().getNode(Activator
 715                                 .getPluginId());
 716
 717                 TreeSet<String> resultStrings = new TreeSet<String>();
 718                 String dirs = prefs.get(PREFS_DIRECTORIES, ""); //$NON-NLS-1$
 719                 if (dirs != null && dirs.length() > 0) {
 720                         StringTokenizer tok = new StringTokenizer(dirs, File.pathSeparator);
 721                         while (tok.hasMoreTokens()) {
 722                                 String dirName = tok.nextToken();
 723                                 File testFile = new File(dirName);
 724                                 if (testFile.exists()) {
 725                                         resultStrings.add(dirName);
 726                                 }
 727                         }
 728                 }
 729
 730                 if (resultStrings.remove(dir)) {
 731                         StringBuilder sb = new StringBuilder();
 732                         for (String gitDirString : resultStrings) {
 733                                 sb.append(gitDirString);
 734                                 sb.append(File.pathSeparatorChar);
 735                         }
 736
 737                         prefs.put(PREFS_DIRECTORIES, sb.toString());
 738                         try {
 739                                 prefs.flush();
 740                         } catch (BackingStoreException e) {
 741                                 IStatus error = new Status(IStatus.ERROR, Activator
 742                                                 .getPluginId(), e.getMessage(), e);
 743                                 Activator.getDefault().getLog().log(error);
 744                         }
 745                 }
 746
 747         }
 748
 749         @Override
 750         public Object getAdapter(Class adapter) {
 751                 return super.getAdapter(adapter);
 752         }
 753
 754         @Override
 755         public void createPartControl(Composite parent) {
 756
 757                 Composite main = new Composite(parent, SWT.NONE);
 758                 GridDataFactory.fillDefaults().grab(true, true).applyTo(main);
 759                 main.setLayout(new GridLayout(1, false));
 760
 761                 tv = new TreeViewer(main);
 762                 tv.setContentProvider(new ContentProvider());
 763                 new LabelProvider(tv);
 764
 765                 GridDataFactory.fillDefaults().grab(true, true).applyTo(tv.getTree());
 766
 767                 addContextMenu();
 768
 769                 addActionsToToolbar();
 770
 771                 scheduleRefresh();
 772         }
 773
 774         private void addContextMenu() {
 775                 tv.getTree().addMenuDetectListener(new MenuDetectListener() {
 776
 777                         public void menuDetected(MenuDetectEvent e) {
 778
 779                                 tv.getTree().setMenu(null);
 780                                 Menu men = new Menu(tv.getTree());
 781
 782                                 TreeItem testItem = tv.getTree().getItem(
 783                                                 tv.getTree().toControl(new Point(e.x, e.y)));
 784                                 if (testItem == null) {
 785                                         addMenuItemsForPanel(men);
 786                                 } else {
 787                                         addMenuItemsForTreeSelection(men);
 788                                         if (men.getItemCount() > 0)
 789                                                 new MenuItem(men, SWT.SEPARATOR);
 790                                         addMenuItemsForPanel(men);
 791                                 }
 792
 793                                 tv.getTree().setMenu(men);
 794                         }
 795                 });
 796         }
 797
 798         private void addMenuItemsForPanel(Menu men) {
 799
 800                 MenuItem importItem = new MenuItem(men, SWT.PUSH);
 801                 importItem
 802                                 .setText(RepositoryViewUITexts.RepositoriesView_ImportRepository_MenuItem);
 803                 importItem.addSelectionListener(new SelectionAdapter() {
 804
 805                         @Override
 806                         public void widgetSelected(SelectionEvent e) {
 807                                 importAction.run();
 808                         }
 809
 810                 });
 811
 812                 MenuItem addItem = new MenuItem(men, SWT.PUSH);
 813                 addItem
 814                                 .setText(RepositoryViewUITexts.RepositoriesView_AddRepository_MenuItem);
 815                 addItem.addSelectionListener(new SelectionAdapter() {
 816
 817                         @Override
 818                         public void widgetSelected(SelectionEvent e) {
 819                                 addAction.run();
 820                         }
 821
 822                 });
 823
 824                 MenuItem refreshItem = new MenuItem(men, SWT.PUSH);
 825                 refreshItem.setText(refreshAction.getText());
 826                 refreshItem.addSelectionListener(new SelectionAdapter() {
 827
 828                         @Override
 829                         public void widgetSelected(SelectionEvent e) {
 830                                 refreshAction.run();
 831                         }
 832
 833                 });
 834
 835         }
 836
 837         @SuppressWarnings("unchecked")
 838         private void addMenuItemsForTreeSelection(Menu men) {
 839                 final List<RepositoryTreeNode<Ref>> refs = new ArrayList<RepositoryTreeNode<Ref>>();
 840                 final List<RepositoryTreeNode<File>> projects = new ArrayList<RepositoryTreeNode<File>>();
 841                 final List<RepositoryTreeNode<Repository>> repos = new ArrayList<RepositoryTreeNode<Repository>>();
 842
 843                 TreeItem[] selectedItems = tv.getTree().getSelection();
 844                 for (TreeItem item : selectedItems) {
 845                         RepositoryTreeNode node = (RepositoryTreeNode) item.getData();
 846                         switch (node.getType()) {
 847                         case PROJ:
 848                                 projects.add(node);
 849                                 break;
 850                         case REF:
 851                                 refs.add(node);
 852                                 break;
 853                         case REPO:
 854                                 repos.add(node);
 855                                 break;
 856                         default:
 857                                 break;
 858                         }
 859                 }
 860
 861                 boolean importableProjectsOnly = !projects.isEmpty() && repos.isEmpty()
 862                                 && refs.isEmpty();
 863
 864                 for (RepositoryTreeNode<File> prj : projects) {
 865                         if (!importableProjectsOnly)
 866                                 break;
 867
 868                         for (IProject proj : ResourcesPlugin.getWorkspace().getRoot()
 869                                         .getProjects()) {
 870                                 if (proj.getLocation().equals(
 871                                                 new Path(prj.getObject().getAbsolutePath())))
 872                                         importableProjectsOnly = false;
 873
 874                         }
 875
 876                 }
 877
 878                 boolean singleRef = refs.size() == 1 && projects.isEmpty()
 879                                 && repos.isEmpty();
 880                 boolean singleRepo = repos.size() == 1 && projects.isEmpty()
 881                                 && refs.isEmpty();
 882
 883                 try {
 884                         singleRef = singleRef
 885                                         && !refs.get(0).getObject().getName()
 886                                                         .equals(Constants.HEAD)
 887                                         && (refs.get(0).getRepository().mapCommit(
 888                                                         refs.get(0).getObject().getLeaf().getObjectId()) != null);
 889                 } catch (IOException e2) {
 890                         singleRef = false;
 891                 }
 892
 893                 if (importableProjectsOnly) {
 894                         MenuItem sync = new MenuItem(men, SWT.PUSH);
 895                         sync
 896                                         .setText(RepositoryViewUITexts.RepositoriesView_ImportProject_MenuItem);
 897
 898                         sync.addSelectionListener(new SelectionAdapter() {
 899
 900                                 @Override
 901                                 public void widgetSelected(SelectionEvent e) {
 902
 903                                         IWorkspaceRunnable wsr = new IWorkspaceRunnable() {
 904
 905                                                 public void run(IProgressMonitor monitor)
 906                                                                 throws CoreException {
 907
 908                                                         for (RepositoryTreeNode<File> projectNode : projects) {
 909                                                                 File file = projectNode.getObject();
 910
 911                                                                 IProjectDescription pd = ResourcesPlugin
 912                                                                                 .getWorkspace().newProjectDescription(
 913                                                                                                 file.getName());
 914                                                                 IPath locationPath = new Path(file
 915                                                                                 .getAbsolutePath());
 916
 917                                                                 pd.setLocation(locationPath);
 918
 919                                                                 ResourcesPlugin.getWorkspace().getRoot()
 920                                                                                 .getProject(pd.getName()).create(pd,
 921                                                                                                 monitor);
 922                                                                 IProject project = ResourcesPlugin
 923                                                                                 .getWorkspace().getRoot().getProject(
 924                                                                                                 pd.getName());
 925                                                                 project.open(monitor);
 926
 927                                                                 File gitDir = projectNode.getRepository()
 928                                                                                 .getDirectory();
 929
 930                                                                 ConnectProviderOperation connectProviderOperation = new ConnectProviderOperation(
 931                                                                                 project, gitDir);
 932                                                                 connectProviderOperation
 933                                                                                 .run(new SubProgressMonitor(monitor, 20));
 934
 935                                                         }
 936
 937                                                 }
 938                                         };
 939
 940                                         try {
 941
 942                                                 ResourcesPlugin.getWorkspace().run(wsr,
 943                                                                 ResourcesPlugin.getWorkspace().getRoot(),
 944                                                                 IWorkspace.AVOID_UPDATE,
 945                                                                 new NullProgressMonitor());
 946
 947                                                 scheduleRefresh();
 948                                         } catch (CoreException e1) {
 949                                                 Activator.getDefault().getLog().log(e1.getStatus());
 950                                         }
 951
 952                                 }
 953
 954                         });
 955                 }
 956
 957                 if (singleRef) {
 958
 959                         MenuItem checkout = new MenuItem(men, SWT.PUSH);
 960                         checkout
 961                                         .setText(RepositoryViewUITexts.RepositoriesView_CheckOut_MenuItem);
 962                         checkout.addSelectionListener(new SelectionAdapter() {
 963
 964                                 @Override
 965                                 public void widgetSelected(SelectionEvent e) {
 966                                         Repository repo = refs.get(0).getRepository();
 967                                         String refName = refs.get(0).myObject.getLeaf().getName();
 968                                         final BranchOperation op = new BranchOperation(repo,
 969                                                         refName);
 970                                         IWorkspaceRunnable wsr = new IWorkspaceRunnable() {
 971
 972                                                 public void run(IProgressMonitor monitor)
 973                                                                 throws CoreException {
 974                                                         op.run(monitor);
 975                                                 }
 976                                         };
 977                                         try {
 978                                                 ResourcesPlugin.getWorkspace().run(wsr,
 979                                                                 ResourcesPlugin.getWorkspace().getRoot(),
 980                                                                 IWorkspace.AVOID_UPDATE,
 981                                                                 new NullProgressMonitor());
 982                                                 scheduleRefresh();
 983                                         } catch (CoreException e1) {
 984                                                 MessageDialog
 985                                                                 .openError(
 986                                                                                 getSite().getShell(),
 987                                                                                 RepositoryViewUITexts.RepositoriesView_Error_WindowTitle,
 988                                                                                 e1.getMessage());
 989                                         }
 990
 991                                 }
 992
 993                         });
 994                 }
 995
 996                 if (singleRepo) {
 997
 998                         MenuItem importProjects = new MenuItem(men, SWT.PUSH);
 999                         importProjects
1000                                         .setText(RepositoryViewUITexts.RepositoriesView_ImportExistingProjects_MenuItem);
1001                         importProjects.addSelectionListener(new SelectionAdapter() {
1002
1003                                 @Override
1004                                 public void widgetSelected(SelectionEvent e) {
1005                                         Wizard wiz = new ExternalProjectImportWizard(repos.get(0)
1006                                                         .getRepository().getWorkDir().getAbsolutePath()) {
1007
1008                                                 @Override
1009                                                 public void addPages() {
1010                                                         super.addPages();
1011                                                         // we could add some page with a single
1012                                                         // checkbox to indicate if we wan
1013                                                         // addPage(new WizardPage("Share") {
1014                                                         //
1015                                                         // public void createControl(
1016                                                         // Composite parent) {
1017                                                         // Composite main = new Composite(
1018                                                         // parent, SWT.NONE);
1019                                                         // main.setLayout(new GridLayout(1,
1020                                                         // false));
1021                                                         // GridDataFactory.fillDefaults()
1022                                                         // .grab(true, true).applyTo(
1023                                                         // main);
1024                                                         // Button but = new Button(main,
1025                                                         // SWT.PUSH);
1026                                                         // but.setText("Push me");
1027                                                         // setControl(main);
1028                                                         //
1029                                                         // }
1030                                                         // });
1031                                                 }
1032
1033                                                 @Override
1034                                                 public boolean performFinish() {
1035
1036                                                         final Set<IPath> previousLocations = new HashSet<IPath>();
1037                                                         // we want to share only new projects
1038                                                         for (IProject project : ResourcesPlugin
1039                                                                         .getWorkspace().getRoot().getProjects()) {
1040                                                                 previousLocations.add(project.getLocation());
1041                                                         }
1042
1043                                                         boolean success = super.performFinish();
1044                                                         if (success) {
1045                                                                 // IWizardPage page = getPage("Share");
1046                                                                 // TODO evaluate checkbox or such, but
1047                                                                 // if we do share
1048                                                                 // always, we don't even need another
1049                                                                 // page
1050
1051                                                                 IWorkspaceRunnable wsr = new IWorkspaceRunnable() {
1052
1053                                                                         public void run(IProgressMonitor monitor)
1054                                                                                         throws CoreException {
1055                                                                                 File gitDir = repos.get(0)
1056                                                                                                 .getRepository().getDirectory();
1057                                                                                 File gitWorkDir = repos.get(0)
1058                                                                                                 .getRepository().getWorkDir();
1059                                                                                 Path workPath = new Path(gitWorkDir
1060                                                                                                 .getAbsolutePath());
1061
1062                                                                                 // we check which projects are
1063                                                                                 // in the workspace
1064                                                                                 // pointing to a location in the
1065                                                                                 // repo's
1066                                                                                 // working directory
1067                                                                                 // and share them
1068                                                                                 for (IProject prj : ResourcesPlugin
1069                                                                                                 .getWorkspace().getRoot()
1070                                                                                                 .getProjects()) {
1071
1072                                                                                         if (workPath.isPrefixOf(prj
1073                                                                                                         .getLocation())) {
1074                                                                                                 if (previousLocations
1075                                                                                                                 .contains(prj
1076                                                                                                                                 .getLocation())) {
1077                                                                                                         continue;
1078                                                                                                 }
1079                                                                                                 ConnectProviderOperation connectProviderOperation = new ConnectProviderOperation(
1080                                                                                                                 prj, gitDir);
1081                                                                                                 connectProviderOperation
1082                                                                                                                 .run(new SubProgressMonitor(
1083                                                                                                                                 monitor, 20));
1084
1085                                                                                         }
1086                                                                                 }
1087
1088                                                                         }
1089                                                                 };
1090
1091                                                                 try {
1092                                                                         ResourcesPlugin.getWorkspace().run(
1093                                                                                         wsr,
1094                                                                                         ResourcesPlugin.getWorkspace()
1095                                                                                                         .getRoot(),
1096                                                                                         IWorkspace.AVOID_UPDATE,
1097                                                                                         new NullProgressMonitor());
1098                                                                         scheduleRefresh();
1099                                                                 } catch (CoreException ce) {
1100                                                                         MessageDialog
1101                                                                                         .openError(
1102                                                                                                         getShell(),
1103                                                                                                         RepositoryViewUITexts.RepositoriesView_Error_WindowTitle,
1104                                                                                                         ce.getMessage());
1105                                                                 }
1106
1107                                                         }
1108                                                         return success;
1109                                                 }
1110
1111                                         };
1112
1113                                         WizardDialog dlg = new WizardDialog(getSite().getShell(),
1114                                                         wiz);
1115                                         dlg.open();
1116                                 }
1117
1118                         });
1119
1120                         // TODO "import existing plug-in" menu item
1121                         // TODO "configure" menu item
1122
1123                         MenuItem remove = new MenuItem(men, SWT.PUSH);
1124                         remove
1125                                         .setText(RepositoryViewUITexts.RepositoriesView_Remove_MenuItem);
1126                         remove.addSelectionListener(new SelectionAdapter() {
1127
1128                                 @Override
1129                                 public void widgetSelected(SelectionEvent e) {
1130
1131                                         List<IProject> projectsToDelete = new ArrayList<IProject>();
1132                                         File workDir = repos.get(0).getRepository().getWorkDir();
1133                                         final IPath wdPath = new Path(workDir.getAbsolutePath());
1134                                         for (IProject prj : ResourcesPlugin.getWorkspace()
1135                                                         .getRoot().getProjects()) {
1136                                                 if (wdPath.isPrefixOf(prj.getLocation())) {
1137                                                         projectsToDelete.add(prj);
1138                                                 }
1139                                         }
1140
1141                                         if (!projectsToDelete.isEmpty()) {
1142                                                 boolean confirmed;
1143                                                 confirmed = confirmProjectDeletion(projectsToDelete);
1144                                                 if (!confirmed) {
1145                                                         return;
1146                                                 }
1147                                         }
1148
1149                                         IWorkspaceRunnable wsr = new IWorkspaceRunnable() {
1150
1151                                                 public void run(IProgressMonitor monitor)
1152                                                                 throws CoreException {
1153
1154                                                         for (IProject prj : ResourcesPlugin.getWorkspace()
1155                                                                         .getRoot().getProjects()) {
1156                                                                 if (wdPath.isPrefixOf(prj.getLocation())) {
1157                                                                         prj.delete(false, false, monitor);
1158                                                                 }
1159                                                         }
1160
1161                                                         Repository repo = repos.get(0).getRepository();
1162                                                         removeDir(repo.getDirectory().getAbsolutePath());
1163                                                         scheduleRefresh();
1164                                                 }
1165                                         };
1166
1167                                         try {
1168                                                 ResourcesPlugin.getWorkspace().run(wsr,
1169                                                                 ResourcesPlugin.getWorkspace().getRoot(),
1170                                                                 IWorkspace.AVOID_UPDATE,
1171                                                                 new NullProgressMonitor());
1172                                         } catch (CoreException e1) {
1173                                                 Activator.getDefault().getLog().log(e1.getStatus());
1174                                         }
1175
1176                                 }
1177
1178                         });
1179
1180                         // TODO delete does not work because of file locks on .pack-files
1181                         // Shawn Pearce has added the following thoughts:
1182
1183                         // Hmm. We probably can't active detect file locks on pack files on
1184                         // Windows, can we?
1185                         // It would be nice if we could support a delete, but only if the
1186                         // repository is
1187                         // reasonably believed to be not-in-use right now.
1188                         //
1189                         // Within EGit you might be able to check GitProjectData and its
1190                         // repositoryCache to
1191                         // see if the repository is open by this workspace. If it is, then
1192                         // we know we shouldn't
1193                         // try to delete it.
1194                         //
1195                         // Some coding might look like this:
1196                         //
1197                         // MenuItem deleteRepo = new MenuItem(men, SWT.PUSH);
1198                         // deleteRepo.setText("Delete");
1199                         // deleteRepo.addSelectionListener(new SelectionAdapter() {
1200                         //
1201                         // @Override
1202                         // public void widgetSelected(SelectionEvent e) {
1203                         //
1204                         // boolean confirmed = MessageDialog.openConfirm(getSite()
1205                         // .getShell(), "Confirm",
1206                         // "This will delete the repository, continue?");
1207                         //
1208                         // if (!confirmed)
1209                         // return;
1210                         //
1211                         // IWorkspaceRunnable wsr = new IWorkspaceRunnable() {
1212                         //
1213                         // public void run(IProgressMonitor monitor)
1214                         // throws CoreException {
1215                         // File workDir = repos.get(0).getRepository()
1216                         // .getWorkDir();
1217                         //
1218                         // File gitDir = repos.get(0).getRepository()
1219                         // .getDirectory();
1220                         //
1221                         // IPath wdPath = new Path(workDir.getAbsolutePath());
1222                         // for (IProject prj : ResourcesPlugin.getWorkspace()
1223                         // .getRoot().getProjects()) {
1224                         // if (wdPath.isPrefixOf(prj.getLocation())) {
1225                         // prj.delete(false, false, monitor);
1226                         // }
1227                         // }
1228                         //
1229                         // repos.get(0).getRepository().close();
1230                         //
1231                         // boolean deleted = deleteRecursively(gitDir, monitor);
1232                         // if (!deleted) {
1233                         // MessageDialog.openError(getSite().getShell(),
1234                         // "Error",
1235                         // "Could not delete Git Repository");
1236                         // }
1237                         //
1238                         // deleted = deleteRecursively(workDir, monitor);
1239                         // if (!deleted) {
1240                         // MessageDialog
1241                         // .openError(getSite().getShell(),
1242                         // "Error",
1243                         // "Could not delete Git Working Directory");
1244                         // }
1245                         //
1246                         // scheduleRefresh();
1247                         // }
1248                         //
1249                         // private boolean deleteRecursively(File fileToDelete,
1250                         // IProgressMonitor monitor) {
1251                         // if (fileToDelete.isDirectory()) {
1252                         // for (File file : fileToDelete.listFiles()) {
1253                         // if (!deleteRecursively(file, monitor)) {
1254                         // return false;
1255                         // }
1256                         // }
1257                         // }
1258                         // monitor.setTaskName(fileToDelete.getAbsolutePath());
1259                         // boolean deleted = fileToDelete.delete();
1260                         // if (!deleted) {
1261                         // System.err.println("Could not delete "
1262                         // + fileToDelete.getAbsolutePath());
1263                         // }
1264                         // return deleted;
1265                         // }
1266                         // };
1267                         //
1268                         // try {
1269                         // ResourcesPlugin.getWorkspace().run(wsr,
1270                         // ResourcesPlugin.getWorkspace().getRoot(),
1271                         // IWorkspace.AVOID_UPDATE,
1272                         // new NullProgressMonitor());
1273                         // } catch (CoreException e1) {
1274                         // // TODO Exception handling
1275                         // e1.printStackTrace();
1276                         // }
1277                         //
1278                         // }
1279                         //
1280                         // });
1281                 }
1282         }
1283
1284         private void addActionsToToolbar() {
1285                 importAction = new Action(
1286                                 RepositoryViewUITexts.RepositoriesView_Import_Button) {
1287
1288                         @Override
1289                         public void run() {
1290                                 GitCloneWizard wiz = new GitCloneWizard();
1291                                 wiz.init(null, null);
1292                                 new WizardDialog(getSite().getShell(), wiz).open();
1293                                 updateDirStrings(new NullProgressMonitor());
1294                         }
1295                 };
1296                 importAction
1297                                 .setToolTipText(RepositoryViewUITexts.RepositoriesView_Clone_Tooltip);
1298
1299                 getViewSite().getActionBars().getToolBarManager().add(importAction);
1300
1301                 addAction = new Action(
1302                                 RepositoryViewUITexts.RepositoriesView_Add_Button) {
1303
1304                         @Override
1305                         public void run() {
1306                                 RepositorySearchDialog sd = new RepositorySearchDialog(
1307                                                 getSite().getShell(), ResourcesPlugin.getWorkspace()
1308                                                                 .getRoot().getLocation().toOSString(),
1309                                                 getGitDirs());
1310                                 if (sd.open() == Window.OK) {
1311                                         Set<String> dirs = new HashSet<String>();
1312                                         dirs.addAll(getGitDirs());
1313                                         if (dirs.addAll(sd.getDirectories()))
1314                                                 saveDirStrings(dirs);
1315                                         scheduleRefresh();
1316                                 }
1317
1318                         }
1319                 };
1320                 addAction
1321                                 .setToolTipText(RepositoryViewUITexts.RepositoriesView_AddRepository_Tooltip);
1322
1323                 getViewSite().getActionBars().getToolBarManager().add(addAction);
1324
1325                 // TODO if we don't show projects, then we probably don't need refresh
1326
1327                 refreshAction = new Action(
1328                                 RepositoryViewUITexts.RepositoriesView_Refresh_Button) {
1329
1330                         @Override
1331                         public void run() {
1332                                 scheduleRefresh();
1333                         }
1334                 };
1335
1336                 getViewSite().getActionBars().getToolBarManager().add(refreshAction);
1337         }
1338
1339         @Override
1340         public void dispose() {
1341                 // make sure to cancel the refresh job
1342                 if (this.scheduledJob != null) {
1343                         this.scheduledJob.cancel();
1344                         this.scheduledJob = null;
1345                 }
1346                 super.dispose();
1347         }
1348
1349         private void scheduleRefresh() {
1350
1351                 Job job = new Job("Refreshing Git Repositories view") { //$NON-NLS-1$
1352
1353                         @Override
1354                         protected IStatus run(IProgressMonitor monitor) {
1355
1356                                 final List<Repository> input;
1357                                 try {
1358                                         input = getRepositoriesFromDirs(monitor);
1359                                 } catch (InterruptedException e) {
1360                                         return new Status(IStatus.ERROR, Activator.getPluginId(), e
1361                                                         .getMessage(), e);
1362                                 }
1363
1364                                 Display.getDefault().syncExec(new Runnable() {
1365
1366                                         public void run() {
1367                                                 // keep expansion state and selection so that we can
1368                                                 // restore the tree
1369                                                 // after update
1370                                                 Object[] expanded = tv.getExpandedElements();
1371                                                 IStructuredSelection sel = (IStructuredSelection) tv
1372                                                                 .getSelection();
1373                                                 tv.setInput(input);
1374                                                 tv.setExpandedElements(expanded);
1375
1376                                                 Object selected = sel.getFirstElement();
1377                                                 if (selected != null)
1378                                                         tv.reveal(selected);
1379                                         }
1380                                 });
1381
1382                                 return new Status(IStatus.OK, Activator.getPluginId(), ""); //$NON-NLS-1$
1383
1384                         }
1385
1386                 };
1387                 job.setSystem(true);
1388
1389                 IWorkbenchSiteProgressService service = (IWorkbenchSiteProgressService) getSite()
1390                                 .getService(IWorkbenchSiteProgressService.class);
1391
1392                 service.schedule(job);
1393
1394                 scheduledJob = job;
1395
1396         }
1397
1398         private List<Repository> getRepositoriesFromDirs(IProgressMonitor monitor)
1399                         throws InterruptedException {
1400
1401                 List<String> gitDirStrings = getGitDirs();
1402                 List<Repository> input = new ArrayList<Repository>();
1403                 for (String dirString : gitDirStrings) {
1404                         if (monitor.isCanceled()) {
1405                                 throw new InterruptedException(
1406                                                 RepositoryViewUITexts.RepositoriesView_ActionCanceled_Message);
1407                         }
1408                         try {
1409                                 File dir = new File(dirString);
1410                                 if (dir.exists() && dir.isDirectory()) {
1411                                         input.add(new Repository(dir));
1412                                 }
1413                         } catch (IOException e) {
1414                                 IStatus error = new Status(IStatus.ERROR, Activator
1415                                                 .getPluginId(), e.getMessage(), e);
1416                                 Activator.getDefault().getLog().log(error);
1417                         }
1418                 }
1419                 return input;
1420         }
1421
1422         private void updateDirStrings(IProgressMonitor monitor) {
1423
1424                 IPath path = ResourcesPlugin.getWorkspace().getRoot().getLocation();
1425                 File root = path.toFile();
1426                 TreeSet<String> dirStrings = new TreeSet<String>();
1427                 recurseDir(root, dirStrings, monitor);
1428                 saveDirStrings(dirStrings);
1429                 scheduleRefresh();
1430
1431         }
1432
1433         private void saveDirStrings(Set<String> gitDirStrings) {
1434                 StringBuilder sb = new StringBuilder();
1435                 for (String gitDirString : gitDirStrings) {
1436                         sb.append(gitDirString);
1437                         sb.append(File.pathSeparatorChar);
1438                 }
1439
1440                 IEclipsePreferences prefs = new InstanceScope().getNode(Activator
1441                                 .getPluginId());
1442                 prefs.put(PREFS_DIRECTORIES, sb.toString());
1443                 try {
1444                         prefs.flush();
1445                 } catch (BackingStoreException e) {
1446                         IStatus error = new Status(IStatus.ERROR, Activator.getPluginId(),
1447                                         e.getMessage(), e);
1448                         Activator.getDefault().getLog().log(error);
1449                 }
1450         }
1451
1452         /**
1453          *
1454          * @param root
1455          * @param strings
1456          * @param monitor
1457          */
1458         public static void recurseDir(File root, TreeSet<String> strings,
1459                         IProgressMonitor monitor) {
1460
1461                 if (!root.exists() || !root.isDirectory()) {
1462                         return;
1463                 }
1464                 File[] children = root.listFiles();
1465                 for (File child : children) {
1466                         if (monitor.isCanceled()) {
1467                                 return;
1468                         }
1469
1470                         if (child.exists() && child.isDirectory()
1471                                         && RepositoryCache.FileKey.isGitRepository(child)) {
1472                                 strings.add(child.getAbsolutePath());
1473                                 return;
1474                         }
1475                         if (child.isDirectory()) {
1476                                 monitor.setTaskName(child.getPath());
1477                                 recurseDir(child, strings, monitor);
1478                         }
1479                 }
1480
1481         }
1482
1483         private static String getRepositoryName(Repository repository) {
1484                 return repository.getDirectory().getParentFile().getName();
1485         }
1486
1487         @Override
1488         public void setFocus() {
1489                 // nothing special
1490         }
1491
1492         @SuppressWarnings("boxing")
1493         private boolean confirmProjectDeletion(List<IProject> projectsToDelete) {
1494                 boolean confirmed;
1495                 confirmed = MessageDialog
1496                                 .openConfirm(
1497                                                 getSite().getShell(),
1498                                                 RepositoryViewUITexts.RepositoriesView_ConfirmProjectDeletion_WindowTitle,
1499                                                 NLS
1500                                                                 .bind(
1501                                                                                 RepositoryViewUITexts.RepositoriesView_ConfirmProjectDeletion_Question,
1502                                                                                 projectsToDelete.size()));
1503                 return confirmed;
1504         }
1505
1506 }