org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/clone/GitCreateProjectViaWizardWizard.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.clone;
  12
  13 import java.lang.reflect.InvocationTargetException;
  14 import java.util.ArrayList;
  15 import java.util.List;
  16
  17 import org.eclipse.core.resources.IProject;
  18 import org.eclipse.core.resources.IProjectDescription;
  19 import org.eclipse.core.resources.IResource;
  20 import org.eclipse.core.resources.ResourcesPlugin;
  21 import org.eclipse.core.runtime.CoreException;
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.core.runtime.Path;
  24 import org.eclipse.egit.core.op.ConnectProviderOperation;
  25 import org.eclipse.egit.ui.Activator;
  26 import org.eclipse.egit.ui.UIText;
  27 import org.eclipse.jface.operation.IRunnableWithProgress;
  28 import org.eclipse.jface.wizard.IWizardPage;
  29 import org.eclipse.jface.wizard.Wizard;
  30 import org.eclipse.jgit.lib.Repository;
  31 import org.eclipse.osgi.util.NLS;
  32 import org.eclipse.swt.widgets.Display;
  33 import org.eclipse.ui.PlatformUI;
  34 import org.eclipse.ui.actions.NewWizardAction;
  35 import org.eclipse.ui.actions.WorkspaceModifyOperation;
  36
  37 /**
  38  * A wizard used to import existing projects from a {@link Repository}
  39  */
  40 public class GitCreateProjectViaWizardWizard extends Wizard implements
  41                 ProjectCreator {
  42
  43         private final Repository myRepository;
  44
  45         private final String myGitDir;
  46
  47         private final IProject[] previousProjects;
  48
  49         private GitSelectWizardPage mySelectionPage;
  50
  51         private GitCreateGeneralProjectPage myCreateGeneralProjectPage;
  52
  53         private GitProjectsImportPage myProjectsImportPage;
  54
  55         private GitShareProjectsPage mySharePage;
  56
  57         /**
  58          * @param repository
  59          * @param path
  60          */
  61         public GitCreateProjectViaWizardWizard(Repository repository, String path) {
  62                 super();
  63                 previousProjects = ResourcesPlugin.getWorkspace().getRoot()
  64                                 .getProjects();
  65                 myRepository = repository;
  66                 myGitDir = path;
  67                 setWindowTitle(NLS.bind(
  68                                 UIText.GitCreateProjectViaWizardWizard_WizardTitle,
  69                                 myRepository.getDirectory().getPath()));
  70
  71                 // the "Import" wizard could be started like this,
  72                 // but throws an Exception if started within a wizard
  73                 // context (no active workbench window found) and the
  74                 // list of available wizards is empty
  75                 // -> investigate if we can include that wizard
  76                 //
  77                 // IHandlerService handlerService = (IHandlerService)
  78                 // PlatformUI.getWorkbench().getService(IHandlerService.class);
  79                 //
  80                 // handlerService.executeCommand("org.eclipse.ui.file.import",
  81
  82         }
  83
  84         @Override
  85         public void addPages() {
  86                 mySelectionPage = new GitSelectWizardPage(myRepository, myGitDir);
  87                 addPage(mySelectionPage);
  88                 myCreateGeneralProjectPage = new GitCreateGeneralProjectPage(myGitDir);
  89                 addPage(myCreateGeneralProjectPage);
  90                 myProjectsImportPage = new GitProjectsImportPage() {
  91
  92                         @Override
  93                         public void setVisible(boolean visible) {
  94                                 setProjectsList(mySelectionPage.getPath());
  95                                 super.setVisible(visible);
  96                         }
  97
  98                 };
  99                 addPage(myProjectsImportPage);
 100                 mySharePage = new GitShareProjectsPage();
 101                 addPage(mySharePage);
 102         }
 103
 104         @Override
 105         public IWizardPage getNextPage(IWizardPage page) {
 106
 107                 if (page == mySelectionPage) {
 108
 109                         switch (mySelectionPage.getWizardSelection()) {
 110                         case GitSelectWizardPage.EXISTING_PROJECTS_WIZARD:
 111                                 return myProjectsImportPage;
 112                         case GitSelectWizardPage.NEW_WIZARD:
 113                                 if (mySelectionPage.getActionSelection() != GitSelectWizardPage.ACTION_DIALOG_SHARE)
 114                                         return null;
 115                                 else
 116                                         return mySharePage;
 117
 118                         case GitSelectWizardPage.GENERAL_WIZARD:
 119                                 return myCreateGeneralProjectPage;
 120
 121                         }
 122
 123                         return super.getNextPage(page);
 124
 125                 } else if (page == myCreateGeneralProjectPage
 126                                 || page == myProjectsImportPage) {
 127
 128                         if (mySelectionPage.getActionSelection() != GitSelectWizardPage.ACTION_DIALOG_SHARE)
 129                                 return null;
 130                         else
 131                                 return mySharePage;
 132                 }
 133                 return super.getNextPage(page);
 134         }
 135
 136         @Override
 137         public boolean canFinish() {
 138
 139                 boolean showSharePage = mySelectionPage.getActionSelection() == GitSelectWizardPage.ACTION_DIALOG_SHARE;
 140                 boolean showShareComplete = !showSharePage
 141                                 || mySharePage.isPageComplete();
 142
 143                 switch (mySelectionPage.getWizardSelection()) {
 144                 case GitSelectWizardPage.EXISTING_PROJECTS_WIZARD:
 145                         return myProjectsImportPage.isPageComplete() && showShareComplete;
 146                 case GitSelectWizardPage.NEW_WIZARD:
 147                         return showShareComplete;
 148                 case GitSelectWizardPage.GENERAL_WIZARD:
 149                         return myCreateGeneralProjectPage.isPageComplete()
 150                                         && showShareComplete;
 151                 }
 152                 return super.canFinish();
 153
 154         }
 155
 156         @Override
 157         public boolean performFinish() {
 158
 159                 try {
 160
 161                         final int actionSelection = mySelectionPage.getActionSelection();
 162
 163                         final IProject[] projectsToShare;
 164                         if (actionSelection == GitSelectWizardPage.ACTION_DIALOG_SHARE)
 165                                 projectsToShare = mySharePage.getSelectedProjects();
 166                         else
 167                                 projectsToShare = null;
 168
 169                         getContainer().run(true, true, new IRunnableWithProgress() {
 170
 171                                 public void run(IProgressMonitor monitor)
 172                                                 throws InvocationTargetException, InterruptedException {
 173
 174                                         if (actionSelection != GitSelectWizardPage.ACTION_DIALOG_SHARE) {
 175                                                 // in case of the share page, the import is done by the
 176                                                 // share page itself
 177                                                 // TODO this currently must be run in the UI Thread due
 178                                                 // to access to
 179                                                 // SWT widgets
 180                                                 importProjects();
 181                                         }
 182
 183                                         if (actionSelection != GitSelectWizardPage.ACTION_NO_SHARE) {
 184
 185                                                 // TODO scheduling rule?
 186                                                 IProject[] projects;
 187                                                 if (projectsToShare == null)
 188                                                         projects = getAddedProjects();
 189                                                 else
 190                                                         projects = projectsToShare;
 191                                                 for (IProject prj : projects) {
 192                                                         if (monitor.isCanceled())
 193                                                                 throw new InterruptedException();
 194                                                         //
 195                                                         ConnectProviderOperation connectProviderOperation = new ConnectProviderOperation(
 196                                                                         prj, myRepository.getDirectory());
 197                                                         try {
 198                                                                 connectProviderOperation.execute(monitor);
 199                                                         } catch (CoreException e) {
 200                                                                 throw new InvocationTargetException(e);
 201                                                         }
 202                                                 }
 203
 204                                         }
 205
 206                                 }
 207                         });
 208                 } catch (InvocationTargetException e) {
 209                         Activator
 210                                         .handleError(e.getCause().getMessage(), e.getCause(), true);
 211                         return false;
 212                 } catch (InterruptedException e) {
 213                         Activator.handleError(
 214                                         UIText.GitCreateProjectViaWizardWizard_AbortedMessage, e,
 215                                         true);
 216                         return false;
 217                 }
 218                 return true;
 219
 220         }
 221
 222         /**
 223          *
 224          */
 225         public void importProjects() {
 226
 227                 // TODO progress monitoring and cancellation
 228                 Display.getDefault().syncExec(new Runnable() {
 229
 230                         public void run() {
 231
 232                                 switch (mySelectionPage.getWizardSelection()) {
 233                                 case GitSelectWizardPage.EXISTING_PROJECTS_WIZARD:
 234                                         myProjectsImportPage.createProjects();
 235                                         break;
 236                                 case GitSelectWizardPage.NEW_WIZARD:
 237                                         new NewWizardAction(PlatformUI.getWorkbench()
 238                                                         .getActiveWorkbenchWindow()).run();
 239                                         break;
 240                                 case GitSelectWizardPage.GENERAL_WIZARD:
 241                                         try {
 242                                                 final String projectName = myCreateGeneralProjectPage
 243                                                                 .getProjectName();
 244                                                 getContainer().run(true, false,
 245                                                                 new WorkspaceModifyOperation() {
 246
 247                                                                         @Override
 248                                                                         protected void execute(
 249                                                                                         IProgressMonitor monitor)
 250                                                                                         throws CoreException,
 251                                                                                         InvocationTargetException,
 252                                                                                         InterruptedException {
 253
 254                                                                                 final IProjectDescription desc = ResourcesPlugin
 255                                                                                                 .getWorkspace()
 256                                                                                                 .newProjectDescription(
 257                                                                                                                 projectName);
 258                                                                                 desc.setLocation(new Path(myGitDir));
 259
 260                                                                                 IProject prj = ResourcesPlugin
 261                                                                                                 .getWorkspace().getRoot()
 262                                                                                                 .getProject(desc.getName());
 263                                                                                 prj.create(desc, monitor);
 264                                                                                 prj.open(monitor);
 265
 266                                                                                 ResourcesPlugin.getWorkspace()
 267                                                                                                 .getRoot().refreshLocal(
 268                                                                                                                 IResource.DEPTH_ONE,
 269                                                                                                                 monitor);
 270
 271                                                                         }
 272                                                                 });
 273                                         } catch (InvocationTargetException e1) {
 274                                                 Activator.handleError(e1.getMessage(), e1
 275                                                                 .getTargetException(), true);
 276                                         } catch (InterruptedException e1) {
 277                                                 Activator.handleError(e1.getMessage(), e1, true);
 278                                         }
 279                                         break;
 280
 281                                 }
 282                         }
 283                 });
 284         }
 285
 286         public IProject[] getAddedProjects() {
 287
 288                 IProject[] currentProjects = ResourcesPlugin.getWorkspace().getRoot()
 289                                 .getProjects();
 290
 291                 List<IProject> newProjects = new ArrayList<IProject>();
 292
 293                 for (IProject current : currentProjects) {
 294                         boolean found = false;
 295                         for (IProject previous : previousProjects) {
 296                                 if (previous.equals(current)) {
 297                                         found = true;
 298                                         break;
 299                                 }
 300                         }
 301                         if (!found) {
 302                                 newProjects.add(current);
 303                         }
 304                 }
 305
 306                 return newProjects.toArray(new IProject[0]);
 307         }
 308
 309 }