org.spearce.egit.ui/src/org/spearce/egit/ui/internal/clone/GitProjectsImportPage.java

   1 package org.spearce.egit.ui.internal.clone;
   2
   3 /*******************************************************************************
   4  * Copyright (c) 2004, 2008 IBM Corporation and others.
   5  * Copyright (C) 2007, Martin Oberhuber (martin.oberhuber@windriver.com)
   6  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
   7  *
   8  * All rights reserved. This program and the accompanying materials
   9  * are made available under the terms of the Eclipse Public License v1.0
  10  * See LICENSE for the full license text, also available.
  11  *******************************************************************************/
  12
  13 import java.io.File;
  14 import java.io.IOException;
  15 import java.lang.reflect.InvocationTargetException;
  16 import java.util.ArrayList;
  17 import java.util.Collection;
  18 import java.util.HashSet;
  19 import java.util.Iterator;
  20 import java.util.List;
  21 import java.util.Set;
  22
  23 import org.eclipse.core.resources.IProject;
  24 import org.eclipse.core.resources.IProjectDescription;
  25 import org.eclipse.core.resources.IResource;
  26 import org.eclipse.core.resources.IWorkspace;
  27 import org.eclipse.core.resources.ResourcesPlugin;
  28 import org.eclipse.core.runtime.CoreException;
  29 import org.eclipse.core.runtime.IPath;
  30 import org.eclipse.core.runtime.IProgressMonitor;
  31 import org.eclipse.core.runtime.IStatus;
  32 import org.eclipse.core.runtime.OperationCanceledException;
  33 import org.eclipse.core.runtime.Path;
  34 import org.eclipse.core.runtime.Platform;
  35 import org.eclipse.core.runtime.Status;
  36 import org.eclipse.core.runtime.SubProgressMonitor;
  37 import org.eclipse.jface.dialogs.Dialog;
  38 import org.eclipse.jface.dialogs.ErrorDialog;
  39 import org.eclipse.jface.operation.IRunnableWithProgress;
  40 import org.eclipse.jface.viewers.CheckStateChangedEvent;
  41 import org.eclipse.jface.viewers.CheckboxTreeViewer;
  42 import org.eclipse.jface.viewers.ICheckStateListener;
  43 import org.eclipse.jface.viewers.ITreeContentProvider;
  44 import org.eclipse.jface.viewers.LabelProvider;
  45 import org.eclipse.jface.viewers.Viewer;
  46 import org.eclipse.jface.viewers.ViewerComparator;
  47 import org.eclipse.jface.wizard.WizardPage;
  48 import org.eclipse.osgi.util.NLS;
  49 import org.eclipse.swt.SWT;
  50 import org.eclipse.swt.events.SelectionAdapter;
  51 import org.eclipse.swt.events.SelectionEvent;
  52 import org.eclipse.swt.layout.GridData;
  53 import org.eclipse.swt.layout.GridLayout;
  54 import org.eclipse.swt.widgets.Button;
  55 import org.eclipse.swt.widgets.Composite;
  56 import org.eclipse.swt.widgets.Label;
  57 import org.eclipse.ui.actions.WorkspaceModifyOperation;
  58 import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
  59 import org.eclipse.ui.internal.ide.StatusUtil;
  60 import org.eclipse.ui.internal.wizards.datatransfer.WizardProjectsImportPage;
  61 import org.eclipse.ui.statushandlers.StatusManager;
  62 import org.eclipse.ui.wizards.datatransfer.IImportStructureProvider;
  63 import org.spearce.egit.core.op.ConnectProviderOperation;
  64 import org.spearce.egit.ui.Activator;
  65 import org.spearce.egit.ui.UIText;
  66
  67 /**
  68  * The GitWizardProjectsImportPage is the page that allows the user to import
  69  * projects from a particular location. This is a modified copy of
  70  * {@link WizardProjectsImportPage}
  71  */
  72 public class GitProjectsImportPage extends WizardPage {
  73
  74         /**
  75          * The name of the folder containing metadata information for the workspace.
  76          */
  77         public static final String METADATA_FOLDER = ".metadata"; //$NON-NLS-1$
  78
  79         /**
  80          * The import structure provider.
  81          */
  82         private IImportStructureProvider structureProvider;
  83
  84         class ProjectRecord {
  85                 File projectSystemFile;
  86
  87                 String projectName;
  88
  89                 Object parent;
  90
  91                 int level;
  92
  93                 IProjectDescription description;
  94
  95                 /**
  96                  * Create a record for a project based on the info in the file.
  97                  *
  98                  * @param file
  99                  */
 100                 ProjectRecord(File file) {
 101                         projectSystemFile = file;
 102                         setProjectName();
 103                 }
 104
 105                 /**
 106                  * @param parent
 107                  *            The parent folder of the .project file
 108                  * @param level
 109                  *            The number of levels deep in the provider the file is
 110                  */
 111                 ProjectRecord(Object parent, int level) {
 112                         this.parent = parent;
 113                         this.level = level;
 114                         setProjectName();
 115                 }
 116
 117                 /**
 118                  * Set the name of the project based on the projectFile.
 119                  */
 120                 private void setProjectName() {
 121                         try {
 122                                 // If we don't have the project name try again
 123                                 if (projectName == null) {
 124                                         IPath path = new Path(projectSystemFile.getPath());
 125                                         // if the file is in the default location, use the directory
 126                                         // name as the project name
 127                                         if (isDefaultLocation(path)) {
 128                                                 projectName = path.segment(path.segmentCount() - 2);
 129                                                 description = IDEWorkbenchPlugin.getPluginWorkspace()
 130                                                                 .newProjectDescription(projectName);
 131                                         } else {
 132                                                 description = IDEWorkbenchPlugin.getPluginWorkspace()
 133                                                                 .loadProjectDescription(path);
 134                                                 projectName = description.getName();
 135                                         }
 136
 137                                 }
 138                         } catch (CoreException e) {
 139                                 // no good couldn't get the name
 140                         }
 141                 }
 142
 143                 /**
 144                  * Returns whether the given project description file path is in the
 145                  * default location for a project
 146                  *
 147                  * @param path
 148                  *            The path to examine
 149                  * @return Whether the given path is the default location for a project
 150                  */
 151                 private boolean isDefaultLocation(IPath path) {
 152                         // The project description file must at least be within the project,
 153                         // which is within the workspace location
 154                         if (path.segmentCount() < 2)
 155                                 return false;
 156                         return path.removeLastSegments(2).toFile().equals(
 157                                         Platform.getLocation().toFile());
 158                 }
 159
 160                 /**
 161                  * Get the name of the project
 162                  *
 163                  * @return String
 164                  */
 165                 public String getProjectName() {
 166                         return projectName;
 167                 }
 168
 169                 /**
 170                  * Gets the label to be used when rendering this project record in the
 171                  * UI.
 172                  *
 173                  * @return String the label
 174                  * @since 3.4
 175                  */
 176                 public String getProjectLabel() {
 177                         if (description == null)
 178                                 return projectName;
 179
 180                         String path = projectSystemFile == null ? structureProvider
 181                                         .getLabel(parent) : projectSystemFile.getParent();
 182
 183                         return NLS.bind(UIText.WizardProjectsImportPage_projectLabel,
 184                                         projectName, path);
 185                 }
 186         }
 187
 188         private CheckboxTreeViewer projectsList;
 189
 190         private ProjectRecord[] selectedProjects = new ProjectRecord[0];
 191
 192         private IProject[] wsProjects;
 193
 194         // The last selected path to minimize searches
 195         private String lastPath;
 196
 197         // The last time that the file or folder at the selected path was modified
 198         // to mimize searches
 199         private long lastModified;
 200
 201         private Button shareCheckBox;
 202
 203         private boolean share;
 204
 205         /**
 206          * Creates a new project creation wizard page.
 207          */
 208         public GitProjectsImportPage() {
 209                 this("gitWizardExternalProjectsPage"); //$NON-NLS-1$
 210         }
 211
 212         /**
 213          * Create a new instance of the receiver.
 214          *
 215          * @param pageName
 216          */
 217         public GitProjectsImportPage(String pageName) {
 218                 super(pageName);
 219                 setPageComplete(false);
 220                 setTitle(UIText.WizardProjectsImportPage_ImportProjectsTitle);
 221                 setDescription(UIText.WizardProjectsImportPage_ImportProjectsDescription);
 222         }
 223
 224         /*
 225          * (non-Javadoc)
 226          *
 227          * @see
 228          * org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets
 229          * .Composite)
 230          */
 231         public void createControl(Composite parent) {
 232
 233                 initializeDialogUnits(parent);
 234
 235                 Composite workArea = new Composite(parent, SWT.NONE);
 236                 setControl(workArea);
 237
 238                 workArea.setLayout(new GridLayout());
 239                 workArea.setLayoutData(new GridData(GridData.FILL_BOTH
 240                                 | GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL));
 241
 242                 createProjectsRoot(workArea);
 243                 createProjectsList(workArea);
 244                 createOptionsArea(workArea);
 245                 Dialog.applyDialogFont(workArea);
 246
 247         }
 248
 249         /**
 250          * Create the area with the extra options.
 251          *
 252          * @param workArea
 253          */
 254         private void createOptionsArea(Composite workArea) {
 255                 Composite optionsGroup = new Composite(workArea, SWT.NONE);
 256                 optionsGroup.setLayout(new GridLayout());
 257                 optionsGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
 258
 259                 shareCheckBox = new Button(optionsGroup, SWT.CHECK);
 260                 shareCheckBox.setText(UIText.WizardProjectsImportPage_enableGit);
 261                 shareCheckBox.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
 262                 shareCheckBox.setSelection(share = true);
 263                 shareCheckBox.addSelectionListener(new SelectionAdapter() {
 264                         public void widgetSelected(SelectionEvent e) {
 265                                 share = shareCheckBox.getSelection();
 266                         }
 267                 });
 268         }
 269
 270         /**
 271          * Create the checkbox list for the found projects.
 272          *
 273          * @param workArea
 274          */
 275         private void createProjectsList(Composite workArea) {
 276
 277                 Label title = new Label(workArea, SWT.NONE);
 278                 title.setText(UIText.WizardProjectsImportPage_ProjectsListTitle);
 279
 280                 Composite listComposite = new Composite(workArea, SWT.NONE);
 281                 GridLayout layout = new GridLayout();
 282                 layout.numColumns = 2;
 283                 layout.marginWidth = 0;
 284                 layout.makeColumnsEqualWidth = false;
 285                 listComposite.setLayout(layout);
 286
 287                 listComposite.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
 288                                 | GridData.GRAB_VERTICAL | GridData.FILL_BOTH));
 289
 290                 projectsList = new CheckboxTreeViewer(listComposite, SWT.BORDER);
 291                 GridData listData = new GridData(GridData.GRAB_HORIZONTAL
 292                                 | GridData.GRAB_VERTICAL | GridData.FILL_BOTH);
 293                 projectsList.getControl().setLayoutData(listData);
 294
 295                 projectsList.setContentProvider(new ITreeContentProvider() {
 296
 297                         /*
 298                          * (non-Javadoc)
 299                          *
 300                          * @see
 301                          * org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java
 302                          * .lang.Object)
 303                          */
 304                         public Object[] getChildren(Object parentElement) {
 305                                 return null;
 306                         }
 307
 308                         /*
 309                          * (non-Javadoc)
 310                          *
 311                          * @see
 312                          * org.eclipse.jface.viewers.IStructuredContentProvider#getElements
 313                          * (java.lang.Object)
 314                          */
 315                         public Object[] getElements(Object inputElement) {
 316                                 return getValidProjects();
 317                         }
 318
 319                         /*
 320                          * (non-Javadoc)
 321                          *
 322                          * @see
 323                          * org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java
 324                          * .lang.Object)
 325                          */
 326                         public boolean hasChildren(Object element) {
 327                                 return false;
 328                         }
 329
 330                         /*
 331                          * (non-Javadoc)
 332                          *
 333                          * @see
 334                          * org.eclipse.jface.viewers.ITreeContentProvider#getParent(java
 335                          * .lang.Object)
 336                          */
 337                         public Object getParent(Object element) {
 338                                 return null;
 339                         }
 340
 341                         /*
 342                          * (non-Javadoc)
 343                          *
 344                          * @see org.eclipse.jface.viewers.IContentProvider#dispose()
 345                          */
 346                         public void dispose() {
 347
 348                         }
 349
 350                         /*
 351                          * (non-Javadoc)
 352                          *
 353                          * @see
 354                          * org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse
 355                          * .jface.viewers.Viewer, java.lang.Object, java.lang.Object)
 356                          */
 357                         public void inputChanged(Viewer viewer, Object oldInput,
 358                                         Object newInput) {
 359                         }
 360
 361                 });
 362
 363                 projectsList.setLabelProvider(new LabelProvider() {
 364                         /*
 365                          * (non-Javadoc)
 366                          *
 367                          * @see
 368                          * org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
 369                          */
 370                         public String getText(Object element) {
 371                                 return ((ProjectRecord) element).getProjectLabel();
 372                         }
 373                 });
 374
 375                 projectsList.addCheckStateListener(new ICheckStateListener() {
 376                         /*
 377                          * (non-Javadoc)
 378                          *
 379                          * @see
 380                          * org.eclipse.jface.viewers.ICheckStateListener#checkStateChanged
 381                          * (org.eclipse.jface.viewers.CheckStateChangedEvent)
 382                          */
 383                         public void checkStateChanged(CheckStateChangedEvent event) {
 384                                 setPageComplete(projectsList.getCheckedElements().length > 0);
 385                         }
 386                 });
 387
 388                 projectsList.setInput(this);
 389                 projectsList.setComparator(new ViewerComparator());
 390                 createSelectionButtons(listComposite);
 391         }
 392
 393         /**
 394          * Create the selection buttons in the listComposite.
 395          *
 396          * @param listComposite
 397          */
 398         private void createSelectionButtons(Composite listComposite) {
 399                 Composite buttonsComposite = new Composite(listComposite, SWT.NONE);
 400                 GridLayout layout = new GridLayout();
 401                 layout.marginWidth = 0;
 402                 layout.marginHeight = 0;
 403                 buttonsComposite.setLayout(layout);
 404
 405                 buttonsComposite.setLayoutData(new GridData(
 406                                 GridData.VERTICAL_ALIGN_BEGINNING));
 407
 408                 Button selectAll = new Button(buttonsComposite, SWT.PUSH);
 409                 selectAll.setText(UIText.WizardProjectsImportPage_selectAll);
 410                 selectAll.addSelectionListener(new SelectionAdapter() {
 411                         public void widgetSelected(SelectionEvent e) {
 412                                 projectsList.setCheckedElements(selectedProjects);
 413                                 setPageComplete(projectsList.getCheckedElements().length > 0);
 414                         }
 415                 });
 416                 Dialog.applyDialogFont(selectAll);
 417                 setButtonLayoutData(selectAll);
 418
 419                 Button deselectAll = new Button(buttonsComposite, SWT.PUSH);
 420                 deselectAll.setText(UIText.WizardProjectsImportPage_deselectAll);
 421                 deselectAll.addSelectionListener(new SelectionAdapter() {
 422                         /*
 423                          * (non-Javadoc)
 424                          *
 425                          * @see
 426                          * org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse
 427                          * .swt.events.SelectionEvent)
 428                          */
 429                         public void widgetSelected(SelectionEvent e) {
 430
 431                                 projectsList.setCheckedElements(new Object[0]);
 432                                 setPageComplete(false);
 433                         }
 434                 });
 435                 Dialog.applyDialogFont(deselectAll);
 436                 setButtonLayoutData(deselectAll);
 437
 438         }
 439
 440         /**
 441          * Create the area where you select the root directory for the projects.
 442          *
 443          * @param workArea
 444          *            Composite
 445          */
 446         private void createProjectsRoot(Composite workArea) {
 447
 448                 // project specification group
 449                 Composite projectGroup = new Composite(workArea, SWT.NONE);
 450                 GridLayout layout = new GridLayout();
 451                 layout.numColumns = 3;
 452                 layout.makeColumnsEqualWidth = false;
 453                 layout.marginWidth = 0;
 454                 projectGroup.setLayout(layout);
 455                 projectGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
 456
 457         }
 458
 459         /*
 460          * (non-Javadoc) Method declared on IDialogPage. Set the focus on path
 461          * fields when page becomes visible.
 462          */
 463         public void setVisible(boolean visible) {
 464                 super.setVisible(visible);
 465         }
 466
 467         /**
 468          * Update the list of projects based on path.
 469          *
 470          * @param path
 471          */
 472         void setProjectsList(final String path) {
 473                 // on an empty path empty selectedProjects
 474                 if (path == null || path.length() == 0) {
 475                         setMessage(UIText.WizardProjectsImportPage_ImportProjectsDescription);
 476                         selectedProjects = new ProjectRecord[0];
 477                         projectsList.refresh(true);
 478                         projectsList.setCheckedElements(selectedProjects);
 479                         setPageComplete(projectsList.getCheckedElements().length > 0);
 480                         lastPath = path;
 481                         return;
 482                 }
 483
 484                 final File directory = new File(path);
 485                 long modified = directory.lastModified();
 486                 if (path.equals(lastPath) && lastModified == modified) {
 487                         // since the file/folder was not modified and the path did not
 488                         // change, no refreshing is required
 489                         return;
 490                 }
 491
 492                 lastPath = path;
 493                 lastModified = modified;
 494
 495                 try {
 496                         getContainer().run(true, true, new IRunnableWithProgress() {
 497
 498                                 /*
 499                                  * (non-Javadoc)
 500                                  *
 501                                  * @see
 502                                  * org.eclipse.jface.operation.IRunnableWithProgress#run(org
 503                                  * .eclipse.core.runtime.IProgressMonitor)
 504                                  */
 505                                 public void run(IProgressMonitor monitor) {
 506
 507                                         monitor.beginTask(
 508                                                         UIText.WizardProjectsImportPage_SearchingMessage,
 509                                                         100);
 510                                         selectedProjects = new ProjectRecord[0];
 511                                         Collection<File> files = new ArrayList<File>();
 512                                         monitor.worked(10);
 513                                         if (directory.isDirectory()) {
 514
 515                                                 if (!collectProjectFilesFromDirectory(files, directory,
 516                                                                 null, monitor)) {
 517                                                         return;
 518                                                 }
 519                                                 Iterator<File> filesIterator = files.iterator();
 520                                                 selectedProjects = new ProjectRecord[files.size()];
 521                                                 int index = 0;
 522                                                 monitor.worked(50);
 523                                                 monitor
 524                                                                 .subTask(UIText.WizardProjectsImportPage_ProcessingMessage);
 525                                                 while (filesIterator.hasNext()) {
 526                                                         File file = filesIterator.next();
 527                                                         selectedProjects[index] = new ProjectRecord(file);
 528                                                         index++;
 529                                                 }
 530                                         } else {
 531                                                 monitor.worked(60);
 532                                         }
 533                                         monitor.done();
 534                                 }
 535
 536                         });
 537                 } catch (InvocationTargetException e) {
 538                         IDEWorkbenchPlugin.log(e.getMessage(), e);
 539                 } catch (InterruptedException e) {
 540                         // Nothing to do if the user interrupts.
 541                 }
 542
 543                 projectsList.refresh(true);
 544                 projectsList.setCheckedElements(getValidProjects());
 545                 if (getValidProjects().length < selectedProjects.length) {
 546                         setMessage(UIText.WizardProjectsImportPage_projectsInWorkspace,
 547                                         WARNING);
 548                 } else {
 549                         setMessage(UIText.WizardProjectsImportPage_ImportProjectsDescription);
 550                 }
 551                 setPageComplete(projectsList.getCheckedElements().length > 0);
 552         }
 553
 554         /**
 555          * Collect the list of .project files that are under directory into files.
 556          *
 557          * @param files
 558          * @param directory
 559          * @param directoriesVisited
 560          *            Set of canonical paths of directories, used as recursion guard
 561          * @param monitor
 562          *            The monitor to report to
 563          * @return boolean <code>true</code> if the operation was completed.
 564          */
 565         private boolean collectProjectFilesFromDirectory(Collection<File> files,
 566                         File directory, Set<String> directoriesVisited, IProgressMonitor monitor) {
 567
 568                 if (monitor.isCanceled()) {
 569                         return false;
 570                 }
 571                 monitor.subTask(NLS.bind(
 572                                 UIText.WizardProjectsImportPage_CheckingMessage, directory
 573                                                 .getPath()));
 574                 File[] contents = directory.listFiles();
 575                 if (contents == null)
 576                         return false;
 577
 578                 // Initialize recursion guard for recursive symbolic links
 579                 if (directoriesVisited == null) {
 580                         directoriesVisited = new HashSet<String>();
 581                         try {
 582                                 directoriesVisited.add(directory.getCanonicalPath());
 583                         } catch (IOException exception) {
 584                                 StatusManager.getManager().handle(
 585                                                 StatusUtil.newStatus(IStatus.ERROR, exception
 586                                                                 .getLocalizedMessage(), exception));
 587                         }
 588                 }
 589
 590                 // first look for project description files
 591                 final String dotProject = IProjectDescription.DESCRIPTION_FILE_NAME;
 592                 for (int i = 0; i < contents.length; i++) {
 593                         File file = contents[i];
 594                         if (file.isFile() && file.getName().equals(dotProject)) {
 595                                 files.add(file);
 596                                 // don't search sub-directories since we can't have nested
 597                                 // projects
 598                                 return true;
 599                         }
 600                 }
 601                 // no project description found, so recurse into sub-directories
 602                 for (int i = 0; i < contents.length; i++) {
 603                         if (contents[i].isDirectory()) {
 604                                 if (!contents[i].getName().equals(METADATA_FOLDER)) {
 605                                         try {
 606                                                 String canonicalPath = contents[i].getCanonicalPath();
 607                                                 if (!directoriesVisited.add(canonicalPath)) {
 608                                                         // already been here --> do not recurse
 609                                                         continue;
 610                                                 }
 611                                         } catch (IOException exception) {
 612                                                 StatusManager.getManager().handle(
 613                                                                 StatusUtil.newStatus(IStatus.ERROR, exception
 614                                                                                 .getLocalizedMessage(), exception));
 615
 616                                         }
 617                                         collectProjectFilesFromDirectory(files, contents[i],
 618                                                         directoriesVisited, monitor);
 619                                 }
 620                         }
 621                 }
 622                 return true;
 623         }
 624
 625         /**
 626          * Create the selected projects
 627          *
 628          * @return boolean <code>true</code> if all project creations were
 629          *         successful.
 630          */
 631         boolean createProjects() {
 632                 final Object[] selected = projectsList.getCheckedElements();
 633                 WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
 634                         protected void execute(IProgressMonitor monitor)
 635                                         throws InvocationTargetException, InterruptedException {
 636                                 try {
 637                                         monitor.beginTask("", selected.length); //$NON-NLS-1$
 638                                         if (monitor.isCanceled()) {
 639                                                 throw new OperationCanceledException();
 640                                         }
 641                                         for (int i = 0; i < selected.length; i++) {
 642                                                 createExistingProject((ProjectRecord) selected[i],
 643                                                                 new SubProgressMonitor(monitor, 1));
 644                                         }
 645                                 } finally {
 646                                         monitor.done();
 647                                 }
 648                         }
 649                 };
 650                 // run the new project creation operation
 651                 try {
 652                         getContainer().run(true, true, op);
 653                 } catch (InterruptedException e) {
 654                         return false;
 655                 } catch (InvocationTargetException e) {
 656                         // one of the steps resulted in a core exception
 657                         Throwable t = e.getTargetException();
 658                         String message = UIText.WizardProjectImportPage_errorMessage;
 659                         IStatus status;
 660                         if (t instanceof CoreException) {
 661                                 status = ((CoreException) t).getStatus();
 662                         } else {
 663                                 status = new Status(IStatus.ERROR,
 664                                                 IDEWorkbenchPlugin.IDE_WORKBENCH, 1, message, t);
 665                         }
 666                         Activator.logError(message, t);
 667                         ErrorDialog.openError(getShell(), message, null, status);
 668                         return false;
 669                 }
 670                 return true;
 671         }
 672
 673         /**
 674          * Create the project described in record. If it is successful return true.
 675          *
 676          * @param record
 677          * @param monitor
 678          * @return boolean <code>true</code> if successful
 679          * @throws InvocationTargetException
 680          * @throws InterruptedException
 681          */
 682         private boolean createExistingProject(final ProjectRecord record,
 683                         IProgressMonitor monitor) throws InvocationTargetException,
 684                         InterruptedException {
 685                 String projectName = record.getProjectName();
 686                 final IWorkspace workspace = ResourcesPlugin.getWorkspace();
 687                 final IProject project = workspace.getRoot().getProject(projectName);
 688                 if (record.description == null) {
 689                         // error case
 690                         record.description = workspace.newProjectDescription(projectName);
 691                         IPath locationPath = new Path(record.projectSystemFile
 692                                         .getAbsolutePath());
 693
 694                         // If it is under the root use the default location
 695                         if (Platform.getLocation().isPrefixOf(locationPath)) {
 696                                 record.description.setLocation(null);
 697                         } else {
 698                                 record.description.setLocation(locationPath);
 699                         }
 700                 } else {
 701                         record.description.setName(projectName);
 702                 }
 703
 704                 try {
 705                         monitor.beginTask(
 706                                         UIText.WizardProjectsImportPage_CreateProjectsTask, 100);
 707                         project.create(record.description, new SubProgressMonitor(monitor,
 708                                         30));
 709                         int openTicks = share ? 50 : 70;
 710                         project.open(IResource.BACKGROUND_REFRESH, new SubProgressMonitor(
 711                                         monitor, openTicks));
 712                         if (share) {
 713                                 ConnectProviderOperation connectProviderOperation = new ConnectProviderOperation(
 714                                                 project, null);
 715                                 connectProviderOperation
 716                                                 .run(new SubProgressMonitor(monitor, 20));
 717                         }
 718                 } catch (CoreException e) {
 719                         throw new InvocationTargetException(e);
 720                 } finally {
 721                         monitor.done();
 722                 }
 723
 724                 return true;
 725         }
 726
 727         /**
 728          * Method used for test suite.
 729          *
 730          * @return CheckboxTreeViewer the viewer containing all the projects found
 731          */
 732         public CheckboxTreeViewer getProjectsList() {
 733                 return projectsList;
 734         }
 735
 736         /**
 737          * Retrieve all the projects in the current workspace.
 738          *
 739          * @return IProject[] array of IProject in the current workspace
 740          */
 741         private IProject[] getProjectsInWorkspace() {
 742                 if (wsProjects == null) {
 743                         wsProjects = IDEWorkbenchPlugin.getPluginWorkspace().getRoot()
 744                                         .getProjects();
 745                 }
 746                 return wsProjects;
 747         }
 748
 749         /**
 750          * Get the array of valid project records that can be imported from the
 751          * source workspace or archive, selected by the user. If a project with the
 752          * same name exists in both the source workspace and the current workspace,
 753          * it will not appear in the list of projects to import and thus cannot be
 754          * selected for import.
 755          *
 756          * Method declared public for test suite.
 757          *
 758          * @return ProjectRecord[] array of projects that can be imported into the
 759          *         workspace
 760          */
 761         public ProjectRecord[] getValidProjects() {
 762                 List<ProjectRecord> validProjects = new ArrayList<ProjectRecord>();
 763                 for (int i = 0; i < selectedProjects.length; i++) {
 764                         if (!isProjectInWorkspace(selectedProjects[i].getProjectName())) {
 765                                 validProjects.add(selectedProjects[i]);
 766                         }
 767                 }
 768                 return validProjects
 769                                 .toArray(new ProjectRecord[validProjects.size()]);
 770         }
 771
 772         /**
 773          * Determine if the project with the given name is in the current workspace.
 774          *
 775          * @param projectName
 776          *            String the project name to check
 777          * @return boolean true if the project with the given name is in this
 778          *         workspace
 779          */
 780         private boolean isProjectInWorkspace(String projectName) {
 781                 if (projectName == null) {
 782                         return false;
 783                 }
 784                 IProject[] workspaceProjects = getProjectsInWorkspace();
 785                 for (int i = 0; i < workspaceProjects.length; i++) {
 786                         if (projectName.equals(workspaceProjects[i].getName())) {
 787                                 return true;
 788                         }
 789                 }
 790                 return false;
 791         }
 792
 793 }