Java 类org.eclipse.ui.actions.WorkspaceModifyOperation 实例源码

@Override
public void run(IIntroSite site, Properties params) {
    WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
        @Override
        protected void execute(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
            IProject project = createProject(monitor);
            createExample(project);
        }
    };
    try {
        PlatformUI.getWorkbench().getProgressService().run(true, true, op);
        final IIntroManager introManager = PlatformUI.getWorkbench().getIntroManager();
        IIntroPart part = introManager.getIntro();
        introManager.closeIntro(part);
        IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
        IDE.openEditor(page, ResourcesPlugin.getWorkspace().getRoot().getFile(new Path("hello-world/greeter.sol")));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

protected void saveModel(final IFile file) throws InvocationTargetException, InterruptedException {
    WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
        @Override
        protected void execute(IProgressMonitor progressMonitor) {
            try {
                EObject model = createInitialModel();
                EcoreIOUtil.saveModelAs(model, file);
            } finally {
                progressMonitor.done();
            }
        }
    };

    IWizardContainer container = getContainer();
    container.run(false, false, operation);
}

@Override
public boolean performFinish() {
    IRunnableWithProgress op = new WorkspaceModifyOperation(null) {
        @Override
        protected void execute(IProgressMonitor monitor) throws CoreException, InterruptedException {
            ensureSCTNature(getProject(modelFilePage.getContainerFullPath()));
            Resource resource = createDefaultModel(modelFilePage.getURI());
            openModel(resource);
        }
    };
    try {
        getContainer().run(false, true, op);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
    return true;
}

/**
 * Tdestings
 * 
 * @param collector
 * @param matches
 */

private void processMatches(ISpellingProblemCollector collector, List<RuleMatch> matches) {
    WorkspaceModifyOperation workspaceRunnable = new WorkspaceModifyOperation() {
        @Override
        protected void execute(IProgressMonitor monitor)
                throws CoreException, InvocationTargetException, InterruptedException {
            // TODO
            deleteMarkers();
            matches.forEach(match -> {
                collector.accept(new LTSpellingProblem(match));
                addMarker(match);
            });
        }

    };

    try {
        workspaceRunnable.run(null);
    } catch (InvocationTargetException | InterruptedException e) {
        e.printStackTrace();
    }
}

@Override
protected void editorSaved()
{
    super.editorSaved();
    updateOutlinePage();
    updateActionsState();
    WorkspaceModifyOperation op = new WorkspaceModifyOperation()
    {
        @Override
        protected void execute(IProgressMonitor monitor)
        {
            NSISTaskTagUpdater taskTagUpdater = new NSISTaskTagUpdater();
            updateTaskTagMarkers(taskTagUpdater);
        }
    };
    try {
        op.run(null);
    }
    catch (Exception e) {
        EclipseNSISPlugin.getDefault().log(e);
    }
}

private void refreshReportProject( final IProject project )
{
    WorkspaceModifyOperation op = new WorkspaceModifyOperation( ) {

        protected void execute( IProgressMonitor monitor )
                throws CoreException
        {
            project.refreshLocal( IResource.DEPTH_INFINITE, monitor );
        }
    };

    try
    {
        new ProgressMonitorDialog( composite.getShell( ) ).run( false,
                true,
                op );
    }
    catch ( Exception e )
    {
        ExceptionUtil.handle( e );
    }
}

protected IRunnableWithProgress createResourceOperation(IFolder folder,InitialBuildPolicies policies) {
    WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
        @Override
        protected void execute(IProgressMonitor monitor) {
            String resource = "";
            String targetFile = "";
            try {
                for (int i = 0; i < resources.length; i++) {
                    resource = resources[i];
                    targetFile =  targetFiles[i];
                    IFile file =  create(folder, resource, targetFile, monitor);
                    if (file != null) {
                        createdResources.add(file);
                        policies.setFile(file);
                        policies.run();
                        BasicNewResourceWizard.selectAndReveal(file,
                                PlatformUI.getWorkbench().getActiveWorkbenchWindow());
                    }
                }           
            } catch (Exception exception) {
                ResourceManager.logException(exception, "Unable to create " + resource);
            } finally {
                monitor.done();
            }
        }
    };
    return operation;
}

protected IRunnableWithProgress createResourceOperation(IFolder folder) {
    WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
        @Override
        protected void execute(IProgressMonitor monitor)
                throws CoreException, InvocationTargetException, InterruptedException {
        }
    };
    return operation;
}

protected void execute(final IAction action) throws InvocationTargetException, InterruptedException {
       if (action != null && !action.isEnabled()) { 
        action.setEnabled(true);
       } 
       else {
        if(getSelectedResources().length > 0) {
            run(new WorkspaceModifyOperation() {
                public void execute(IProgressMonitor monitor) throws InterruptedException, InvocationTargetException {
                    IResource resource = getSelectedResources()[0];
                    ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource);
                    SvnWizardSetPropertyPage setPropertyPage = new SvnWizardSetPropertyPage(svnResource);
                    SvnWizard wizard = new SvnWizard(setPropertyPage);
                    SvnWizardDialog dialog = new SvnWizardDialog(getShell(), wizard);
                    wizard.setParentDialog(dialog);  
                    if (dialog.open() != SvnWizardDialog.OK) return;

                    try {
                        if (setPropertyPage.getPropertyValue() != null) {
                            svnResource.setSvnProperty(setPropertyPage.getPropertyName(), setPropertyPage.getPropertyValue(),setPropertyPage.getRecurse());
                        } else {
                            svnResource.setSvnProperty(setPropertyPage.getPropertyName(), setPropertyPage.getPropertyFile(),setPropertyPage.getRecurse());
                        }
                        SvnPropertiesView.refreshView();
                    } catch (SVNException e) {
                        throw new InvocationTargetException(e);
                    }
                } 
            }, false /* cancelable */, PROGRESS_BUSYCURSOR);
        }
       }
}

protected void execute(IAction action) throws InvocationTargetException, InterruptedException {
    if (action != null && !action.isEnabled()) { 
        action.setEnabled(true);
    } 
    else {
        if (getSelectedResources() != null && getSelectedResources().length > 0) {
      final IResource[] resources = getSelectedResources(); 
      run(new WorkspaceModifyOperation() {
          protected void execute(IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException {
              try {
            Hashtable table = getProviderMapping(getSelectedResources());
            Set keySet = table.keySet();
            Iterator iterator = keySet.iterator();
            while (iterator.hasNext()) {
                SVNTeamProvider provider = (SVNTeamProvider)iterator.next();
                UnlockResourcesCommand command = new UnlockResourcesCommand(provider.getSVNWorkspaceRoot(), resources, false);
                command.run(Policy.subMonitorFor(monitor,1000));                        
            }
              } catch (TeamException e) {
            throw new InvocationTargetException(e);
        } finally {
            monitor.done();
        }
          }              
      }, true /* cancelable */, PROGRESS_DIALOG);        
        }
    }
}

protected void execute(IAction action) throws InvocationTargetException, InterruptedException {
    if (action != null && !action.isEnabled()) { 
        action.setEnabled(true);
    } 
    else {
        if (getSelectedResources() != null && getSelectedResources().length > 0) {
      final IResource[] resources = getSelectedResources();
      SvnWizardLockPage lockPage = new SvnWizardLockPage(resources);
      SvnWizard wizard = new SvnWizard(lockPage);
      SvnWizardDialog dialog = new SvnWizardDialog(getShell(), wizard);
      wizard.setParentDialog(dialog);
      if (dialog.open() == SvnWizardDialog.OK) {
          final String comment = lockPage.getComment();
          final boolean stealLock = lockPage.isStealLock();
          run(new WorkspaceModifyOperation() {
              protected void execute(IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException {
                  try {
                    Hashtable table = getProviderMapping(getSelectedResources());
                    Set keySet = table.keySet();
                    Iterator iterator = keySet.iterator();
                    while (iterator.hasNext()) {
                        SVNTeamProvider provider = (SVNTeamProvider)iterator.next();
                        LockResourcesCommand command = new LockResourcesCommand(provider.getSVNWorkspaceRoot(), resources, stealLock, comment);
                        command.run(Policy.subMonitorFor(monitor,1000));                        
                    }
                  } catch (TeamException e) {
                    throw new InvocationTargetException(e);
                } finally {
                    monitor.done();
                }
              }              
          }, true /* cancelable */, PROGRESS_DIALOG);
      }
        }
    }
}

public void execute(IAction action) throws InterruptedException, InvocationTargetException {
    // first we ask the user if he really want to add the selected resources if some of them are marked as ignored
       if (!promptForAddOfIgnored()) { 
           return;
       }
    run(new WorkspaceModifyOperation() {
        public void execute(IProgressMonitor monitor) throws InvocationTargetException {
            try {
                   // associate the resources with their respective RepositoryProvider                  
                Hashtable table = getProviderMapping(getSelectedResources());
                Set keySet = table.keySet();
                monitor.beginTask("", keySet.size() * 1000); //$NON-NLS-1$
                monitor.setTaskName(Policy.bind("AddAction.adding")); //$NON-NLS-1$
                Iterator iterator = keySet.iterator();
                while (iterator.hasNext()) {
                    IProgressMonitor subMonitor = Policy.subMonitorFor(monitor, 1000);
                    SVNTeamProvider provider = (SVNTeamProvider)iterator.next();
                    List list = (List)table.get(provider);
                    IResource[] providerResources = (IResource[])list.toArray(new IResource[list.size()]);
                    provider.add(providerResources, IResource.DEPTH_INFINITE, subMonitor);
                }
            } catch (TeamException e) {
                throw new InvocationTargetException(e);
            } finally {
                monitor.done();
            }
        }
    }, true /* cancelable */, PROGRESS_DIALOG);

}

protected void run(SVNTeamProvider provider, SyncInfoSet set, final IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
    final IResource[] resources = set.getResources();
    run(new WorkspaceModifyOperation() {
        protected void execute(IProgressMonitor mon) throws CoreException, InvocationTargetException, InterruptedException {
           for (int i = 0; i < resources.length; i++) {
               File tempFile = null;
               try {
                   tempFile = copyToTempFile(resources[i]);
             } catch (Exception e) {
                 SVNUIPlugin.log(e.getMessage());
                 showErrorMessage(e);
                 return;
             }
             if (monitor.isCanceled()) {
                if (tempFile != null) tempFile.delete();
                return;
             }
                ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resources[i]);
    if (svnResource instanceof LocalResource) ((LocalResource)svnResource).revert(false);
    else svnResource.revert();
    new UpdateOperation(getPart(), resources[i], SVNRevision.HEAD).run(monitor);
    if (monitor.isCanceled()) {
        if (tempFile != null) tempFile.delete();
        return;
    }
    File file = new File(resources[i].getLocation().toString());
    try {
                    copy(tempFile, file);
                } catch (Exception e1) {
                    SVNUIPlugin.log(e1.getMessage());
                    showErrorMessage(e1);
                }
                if (tempFile != null) tempFile.delete();
           }
        }          
    }, true /* cancelable */, PROGRESS_BUSYCURSOR);
}

@Override
public boolean performFinish() {
    AppProjectGenerator generator = new AppProjectGenerator(getTemplateManifestPath());
    generator.setProjectName(mainPage.getProjectName());
    if (!mainPage.useDefaults()) {
        generator.setLocationURI(mainPage.getLocationURI());
    }
    generator.setPackageName("com.example.emptyapp");
    generator.setActivityName("MainActivity");
    generator.setLayoutName("activity_main");

    Map<String, Object> model = new HashMap<>();

    try {
        getContainer().run(true, true, new WorkspaceModifyOperation() {
            @Override
            protected void execute(IProgressMonitor monitor)
                    throws CoreException, InvocationTargetException, InterruptedException {
                monitor.beginTask("Generating project", 1); //$NON-NLS-1$
                generator.generate(model, monitor);
                monitor.done();
            }

            @Override
            public ISchedulingRule getRule() {
                return ResourcesPlugin.getWorkspace().getRoot();
            }
        });
    } catch (InterruptedException | InvocationTargetException e) {
        throw new RuntimeException(e);
    }
    return true;
}

@Override
final protected IRunnableWithProgress createOperation(final IStatus[] errorStatus) {
    final ISchedulingRule rule = null;
    // final IResourceRuleFactory factory = ResourcesPlugin.getWorkspace().getRuleFactory();

    // List<? extends IResource> actionResources = new ArrayList<>(resources);
    // if (shouldPerformResourcePruning()) {
    // actionResources = pruneResources2(actionResources);
    // }
    // final List<? extends IResource> resources = actionResources;

    // final Iterator<? extends IResource> res = resources.iterator();
    // while (res.hasNext()) {
    // rule = MultiRule.combine(rule, factory.refreshRule(res.next()));
    // }
    return new WorkspaceModifyOperation() {
        @Override
        public void execute(final IProgressMonitor monitor) {
            final Iterator<? extends IResource> resourcesEnum = resources.iterator();
            try {
                while (resourcesEnum.hasNext()) {
                    try {
                        final IResource resource = resourcesEnum.next();
                        refreshResource(resource, null);
                    } catch (final CoreException e) {}
                    if (monitor.isCanceled()) { throw new OperationCanceledException(); }
                }
            } finally {
                monitor.done();
            }
        }
    };
}

/**
 * Wrap the job round a IRunnableWithProgress class.
 * @param op The operation to run in this job
 */
private BackgroundJob( IRunnableWithProgress op )
{
   super( op.toString() );
   this.op = op;
   this.setSystem( true );
   if( op instanceof WorkspaceModifyOperation ) {
      this.setRule( ((WorkspaceModifyOperation) op).getRule() );
   }
}

protected void execute(final IAction action) throws InvocationTargetException, InterruptedException {
       if (action != null && !action.isEnabled()) { 
        action.setEnabled(true);
       } 
       else {
        if(getSelectedResources().length > 0) {
            run(new WorkspaceModifyOperation() {
                public void execute(IProgressMonitor monitor) throws InterruptedException, InvocationTargetException {
                    IResource resource = getSelectedResources()[0];
                    ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resource);
                    SvnWizardSetPropertyPage setPropertyPage = new SvnWizardSetPropertyPage(svnResource);
                    SvnWizard wizard = new SvnWizard(setPropertyPage);
                    SvnWizardDialog dialog = new SvnWizardDialog(getShell(), wizard);
                    wizard.setParentDialog(dialog);  
                    if (dialog.open() != SvnWizardDialog.OK) return;

                    try {
                        if (setPropertyPage.getPropertyValue() != null) {
                            svnResource.setSvnProperty(setPropertyPage.getPropertyName(), setPropertyPage.getPropertyValue(),setPropertyPage.getRecurse());
                        } else {
                            svnResource.setSvnProperty(setPropertyPage.getPropertyName(), setPropertyPage.getPropertyFile(),setPropertyPage.getRecurse());
                        }
                        SvnPropertiesView.refreshView();
                    } catch (SVNException e) {
                        throw new InvocationTargetException(e);
                    }
                } 
            }, false /* cancelable */, PROGRESS_BUSYCURSOR);
        }
       }
}

protected void execute(IAction action) throws InvocationTargetException, InterruptedException {
    if (action != null && !action.isEnabled()) { 
        action.setEnabled(true);
    } 
    else {
        if (getSelectedResources() != null && getSelectedResources().length > 0) {
      final IResource[] resources = getSelectedResources(); 
      run(new WorkspaceModifyOperation() {
          protected void execute(IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException {
              try {
            Hashtable table = getProviderMapping(getSelectedResources());
            Set keySet = table.keySet();
            Iterator iterator = keySet.iterator();
            while (iterator.hasNext()) {
                SVNTeamProvider provider = (SVNTeamProvider)iterator.next();
                UnlockResourcesCommand command = new UnlockResourcesCommand(provider.getSVNWorkspaceRoot(), resources, false);
                command.run(Policy.subMonitorFor(monitor,1000));                        
            }
              } catch (TeamException e) {
            throw new InvocationTargetException(e);
        } finally {
            monitor.done();
        }
          }              
      }, true /* cancelable */, PROGRESS_DIALOG);        
        }
    }
}

protected void execute(IAction action) throws InvocationTargetException, InterruptedException {
    if (action != null && !action.isEnabled()) { 
        action.setEnabled(true);
    } 
    else {
        if (getSelectedResources() != null && getSelectedResources().length > 0) {
      final IResource[] resources = getSelectedResources();
      SvnWizardLockPage lockPage = new SvnWizardLockPage(resources);
      SvnWizard wizard = new SvnWizard(lockPage);
      SvnWizardDialog dialog = new SvnWizardDialog(getShell(), wizard);
      wizard.setParentDialog(dialog);
      if (dialog.open() == SvnWizardDialog.OK) {
          final String comment = lockPage.getComment();
          final boolean stealLock = lockPage.isStealLock();
          run(new WorkspaceModifyOperation() {
              protected void execute(IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException {
                  try {
                    Hashtable table = getProviderMapping(getSelectedResources());
                    Set keySet = table.keySet();
                    Iterator iterator = keySet.iterator();
                    while (iterator.hasNext()) {
                        SVNTeamProvider provider = (SVNTeamProvider)iterator.next();
                        LockResourcesCommand command = new LockResourcesCommand(provider.getSVNWorkspaceRoot(), resources, stealLock, comment);
                        command.run(Policy.subMonitorFor(monitor,1000));                        
                    }
                  } catch (TeamException e) {
                    throw new InvocationTargetException(e);
                } finally {
                    monitor.done();
                }
              }              
          }, true /* cancelable */, PROGRESS_DIALOG);
      }
        }
    }
}

public void execute(IAction action) throws InterruptedException, InvocationTargetException {
    // first we ask the user if he really want to add the selected resources if some of them are marked as ignored
       if (!promptForAddOfIgnored()) { 
           return;
       }
    run(new WorkspaceModifyOperation() {
        public void execute(IProgressMonitor monitor) throws InvocationTargetException {
            try {
                   // associate the resources with their respective RepositoryProvider                  
                Hashtable table = getProviderMapping(getSelectedResources());
                Set keySet = table.keySet();
                monitor.beginTask("", keySet.size() * 1000); //$NON-NLS-1$
                monitor.setTaskName(Policy.bind("AddAction.adding")); //$NON-NLS-1$
                Iterator iterator = keySet.iterator();
                while (iterator.hasNext()) {
                    IProgressMonitor subMonitor = Policy.subMonitorFor(monitor, 1000);
                    SVNTeamProvider provider = (SVNTeamProvider)iterator.next();
                    List list = (List)table.get(provider);
                    IResource[] providerResources = (IResource[])list.toArray(new IResource[list.size()]);
                    provider.add(providerResources, IResource.DEPTH_INFINITE, subMonitor);
                }
            } catch (TeamException e) {
                throw new InvocationTargetException(e);
            } finally {
                monitor.done();
            }
        }
    }, true /* cancelable */, PROGRESS_DIALOG);

}

protected void run(SVNTeamProvider provider, SyncInfoSet set, final IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
    final IResource[] resources = set.getResources();
    run(new WorkspaceModifyOperation() {
        protected void execute(IProgressMonitor mon) throws CoreException, InvocationTargetException, InterruptedException {
           for (int i = 0; i < resources.length; i++) {
               File tempFile = null;
               try {
                   tempFile = copyToTempFile(resources[i]);
             } catch (Exception e) {
                 SVNUIPlugin.log(e.getMessage());
                 showErrorMessage(e);
                 return;
             }
             if (monitor.isCanceled()) {
                if (tempFile != null) tempFile.delete();
                return;
             }
                ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(resources[i]);
    if (svnResource instanceof LocalResource) ((LocalResource)svnResource).revert(false);
    else svnResource.revert();
    new UpdateOperation(getPart(), resources[i], SVNRevision.HEAD).run(monitor);
    if (monitor.isCanceled()) {
        if (tempFile != null) tempFile.delete();
        return;
    }
    File file = new File(resources[i].getLocation().toString());
    try {
                    copy(tempFile, file);
                } catch (Exception e1) {
                    SVNUIPlugin.log(e1.getMessage());
                    showErrorMessage(e1);
                }
                if (tempFile != null) tempFile.delete();
           }
        }          
    }, true /* cancelable */, PROGRESS_BUSYCURSOR);
}

protected boolean performSaveAs() {
    final String newPlanName = getNewPlanName();
    if (ResourcesPlugin.getWorkspace().getRoot().getProject(newPlanName).exists()) {
        String message = "Project '" + newPlanName + "' already exists.";
        Status status = new Status(IStatus.ERROR, EditorPlugin.ID, message);
        ErrorDialog.openError(getShell(), "Invalid input", null, status);
        return false;
    }
    WorkspaceModifyOperation operation = createSaveAsOperation(newPlanName);
    return executeSaveAsOperation(operation, false, true);
}

void handleDropMove() {
    final List<IResource> elements= getResources();
    if (elements == null || elements.size() == 0)
        return;

    WorkspaceModifyOperation op= new WorkspaceModifyOperation() {
        @Override
        public void execute(IProgressMonitor monitor) throws CoreException {
            try {
                monitor.beginTask(PackagesMessages.DragAdapter_deleting, elements.size());
                MultiStatus status= createMultiStatus();
                Iterator<IResource> iter= elements.iterator();
                while(iter.hasNext()) {
                    IResource resource= iter.next();
                    try {
                        monitor.subTask(BasicElementLabels.getPathLabel(resource.getFullPath(), true));
                        resource.delete(true, null);

                    } catch (CoreException e) {
                        status.add(e.getStatus());
                    } finally {
                        monitor.worked(1);
                    }
                }
                if (!status.isOK()) {
                    throw new CoreException(status);
                }
            } finally {
                monitor.done();
            }
        }
    };
    runOperation(op, true, false);
}

private void handleRefresh() {
    final Set<IResource> roots= collectRoots(getResources());

    WorkspaceModifyOperation op= new WorkspaceModifyOperation() {
        @Override
        public void execute(IProgressMonitor monitor) throws CoreException {
            try {
                monitor.beginTask(PackagesMessages.DragAdapter_refreshing, roots.size());
                MultiStatus status= createMultiStatus();
                Iterator<IResource> iter= roots.iterator();
                while (iter.hasNext()) {
                    IResource r= iter.next();
                    try {
                        r.refreshLocal(IResource.DEPTH_ONE, new SubProgressMonitor(monitor, 1));
                    } catch (CoreException e) {
                        status.add(e.getStatus());
                    }
                }
                if (!status.isOK()) {
                    throw new CoreException(status);
                }
            } finally {
                monitor.done();
            }
        }
    };

    runOperation(op, true, false);
}

void handleDropMove() {
    final List<IResource> elements= getResources();
    if (elements == null || elements.size() == 0)
        return;

    WorkspaceModifyOperation op= new WorkspaceModifyOperation() {
        @Override
        public void execute(IProgressMonitor monitor) throws CoreException {
            try {
                monitor.beginTask(PackagesMessages.DragAdapter_deleting, elements.size());
                MultiStatus status= createMultiStatus();
                Iterator<IResource> iter= elements.iterator();
                while(iter.hasNext()) {
                    IResource resource= iter.next();
                    try {
                        monitor.subTask(BasicElementLabels.getPathLabel(resource.getFullPath(), true));
                        resource.delete(true, null);

                    } catch (CoreException e) {
                        status.add(e.getStatus());
                    } finally {
                        monitor.worked(1);
                    }
                }
                if (!status.isOK()) {
                    throw new CoreException(status);
                }
            } finally {
                monitor.done();
            }
        }
    };
    runOperation(op, true, false);
}

private void handleRefresh() {
    final Set<IResource> roots= collectRoots(getResources());

    WorkspaceModifyOperation op= new WorkspaceModifyOperation() {
        @Override
        public void execute(IProgressMonitor monitor) throws CoreException {
            try {
                monitor.beginTask(PackagesMessages.DragAdapter_refreshing, roots.size());
                MultiStatus status= createMultiStatus();
                Iterator<IResource> iter= roots.iterator();
                while (iter.hasNext()) {
                    IResource r= iter.next();
                    try {
                        r.refreshLocal(IResource.DEPTH_ONE, new SubProgressMonitor(monitor, 1));
                    } catch (CoreException e) {
                        status.add(e.getStatus());
                    }
                }
                if (!status.isOK()) {
                    throw new CoreException(status);
                }
            } finally {
                monitor.done();
            }
        }
    };

    runOperation(op, true, false);
}

public boolean performFinish() {
    WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
        protected void execute(IProgressMonitor monitor)
                throws CoreException, InvocationTargetException, InterruptedException {
            javaPage.performFinish(monitor);
        }
    };
    try {
        getContainer().run(false, true, op);

        IJavaProject newElement = javaPage.getJavaProject();

        GW4ENature.setGW4ENature(newElement.getProject());

        IWorkingSet[] workingSets = mainPage.getWorkingSets();
        if (workingSets.length > 0) {
            PlatformUI.getWorkbench().getWorkingSetManager().addToWorkingSets(newElement, workingSets);
        }

        BasicNewProjectResourceWizard.updatePerspective(fConfigElement);
        BasicNewResourceWizard.selectAndReveal(newElement.getResource(),
                PlatformUI.getWorkbench().getActiveWorkbenchWindow());

        fMavenPage.create();

        if (provider==null) {
            provider = new NoneTemplate();
        }

        IPath p = newElement.getProject().getFullPath().append(targetFolder.getName()).append(fMavenPage.getPackagePath());
        ResourceManager.ensureFolderPath(p);

        IFolder f = (IFolder) ResourceManager.getResource(p.toString());


        IRunnableWithProgress operation = provider.createResourceOperation(newElement.getProject(),f,policies,filename);
        getContainer().run(false, false, operation);
        return provider.openInEditor(workbench);
    } catch (Exception e) {
        ResourceManager.logException(e);
        return false;
    }
}

protected void makeActions() {
    IShellProvider shellProvider = new IShellProvider() {

        @Override
        public Shell getShell() {
            return shell;
        }
    };

    refreshAction = new RefreshAction(shellProvider) {
        @Override
        public void run() {
            final IStatus[] errorStatus = new IStatus[1];
            errorStatus[0] = Status.OK_STATUS;
            final WorkspaceModifyOperation op = (WorkspaceModifyOperation) createOperation(errorStatus);
            WorkspaceJob job = new WorkspaceJob("refesh") {
                @Override
                public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
                    try {
                        op.run(monitor);
                        if (shell != null && !shell.isDisposed()) {
                            shell.getDisplay().asyncExec(new Runnable() {

                                @Override
                                public void run() {
                                    StructuredViewer viewer = getActionSite().getStructuredViewer();
                                    if (viewer != null && viewer.getControl() != null && !viewer.getControl()
                                            .isDisposed()) {
                                        viewer.refresh();
                                    }

                                }
                            });
                        }
                    } catch (InvocationTargetException e) {
                        String msg = NLS.bind("Exception in {0}. run: {1}", getClass().getName(),
                                e.getTargetException());
                        throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, 
                                IStatus.ERROR, msg, e.getTargetException()));
                    } catch (InterruptedException ex) {
                        return Status.CANCEL_STATUS;
                    }
                    return errorStatus[0];
                }
            };
            ISchedulingRule rule = op.getRule();
            if (rule != null) {
                job.setRule(rule);
            }
            job.setUser(true);
            job.schedule();
        }
    };
    refreshAction.setDisabledImageDescriptor(getImageDescriptor("icons/refresh_nav_disabled.gif"));
       refreshAction.setImageDescriptor(getImageDescriptor("icons/refresh_nav_enabled.gif"));
       refreshAction.setActionDefinitionId(IWorkbenchCommandConstants.FILE_REFRESH);
}

/**
    * get the WorkspaceModifyOperation. The operation will :
    * - delete svn directories if this option has been chosen
    * - unmap the project
    * @return
    */
private IRunnableWithProgress getOperation() {
    return new WorkspaceModifyOperation() {
        public void execute(IProgressMonitor monitor) throws InvocationTargetException {
            try {
                // maps the selected resources (projects) to their providers
                   Hashtable table = getProviderMapping(getSelectedResources());
                Set keySet = table.keySet();
                monitor.beginTask("", keySet.size() * 1000); //$NON-NLS-1$
                monitor.setTaskName(Policy.bind("Unmanage.unmanaging")); //$NON-NLS-1$
                Iterator iterator = keySet.iterator();
                while (iterator.hasNext()) {
                    IProgressMonitor subMonitor = new InfiniteSubProgressMonitor(monitor, 1000);
                    subMonitor.beginTask(null, 100);
                    SVNTeamProvider provider = (SVNTeamProvider)iterator.next();

                       // get the resources (projects) to unmanage for the given provider
                       List list = (List)table.get(provider);
                    IResource[] providerResources = (IResource[])list.toArray(new IResource[list.size()]);
                    for (int i = 0; i < providerResources.length; i++) {
                        // get the folder for the project
                           IResource resource = providerResources[i];
                        ISVNLocalFolder folder = SVNWorkspaceRoot.getSVNFolderFor((IContainer) resource);
                        try {
                            if(deleteContent) {
                                folder.unmanage(Policy.subMonitorFor(subMonitor, 10));
                            }
                        } finally {
                            // We want to remove the nature even if the unmanage operation fails
                            RepositoryProvider.unmap((IProject)resource);                           
                        }
                    }                                           
                }                                       
            } catch (TeamException e) {
                throw new InvocationTargetException(e);
            } finally {
                monitor.done();
            }
        }
    };
}

/**
    * get the WorkspaceModifyOperation. The operation will :
    * - delete svn directories if this option has been chosen
    * - unmap the project
    * @return
    */
private IRunnableWithProgress getOperation() {
    return new WorkspaceModifyOperation() {
        public void execute(IProgressMonitor monitor) throws InvocationTargetException {
            try {
                // maps the selected resources (projects) to their providers
                   Hashtable table = getProviderMapping(getSelectedResources());
                Set keySet = table.keySet();
                monitor.beginTask("", keySet.size() * 1000); //$NON-NLS-1$
                monitor.setTaskName(Policy.bind("Unmanage.unmanaging")); //$NON-NLS-1$
                Iterator iterator = keySet.iterator();
                while (iterator.hasNext()) {
                    IProgressMonitor subMonitor = new InfiniteSubProgressMonitor(monitor, 1000);
                    subMonitor.beginTask(null, 100);
                    SVNTeamProvider provider = (SVNTeamProvider)iterator.next();

                       // get the resources (projects) to unmanage for the given provider
                       List list = (List)table.get(provider);
                    IResource[] providerResources = (IResource[])list.toArray(new IResource[list.size()]);
                    for (int i = 0; i < providerResources.length; i++) {
                        // get the folder for the project
                           IResource resource = providerResources[i];
                        ISVNLocalFolder folder = SVNWorkspaceRoot.getSVNFolderFor((IContainer) resource);
                        try {
                            if(deleteContent) {
                                folder.unmanage(Policy.subMonitorFor(subMonitor, 10));
                            }
                        } finally {
                            // We want to remove the nature even if the unmanage operation fails
                            RepositoryProvider.unmap((IProject)resource);                           
                        }
                    }                                           
                }                                       
            } catch (TeamException e) {
                throw new InvocationTargetException(e);
            } finally {
                monitor.done();
            }
        }
    };
}

private void refreshResource( IPath resPath )
{
    IResource[] res = ResourcesPlugin.getWorkspace( )
            .getRoot( )
            .findFilesForLocation( resPath );

    if ( res.length == 0 )
    {
        res = ResourcesPlugin.getWorkspace( )
                .getRoot( )
                .findContainersForLocation( resPath );

        if ( res.length == 0 )
        {
            // not resources within the workspace
            return;
        }
    }

    try
    {
        final IResource[] targes = res;

        new WorkspaceModifyOperation( ) {

            protected void execute( IProgressMonitor monitor )
                    throws CoreException
            {
                for ( IResource rc : targes )
                {
                    rc.refreshLocal( IResource.DEPTH_INFINITE, null );
                }
            }
        }.run( null );
    }
    catch ( Exception e )
    {
        ExceptionUtil.handle( e );
    }

}

public void doSaveAs() {
    // Show a SaveAs dialog
    Shell shell = getSite().getWorkbenchWindow().getShell();
    SaveAsDialog dialog = new SaveAsDialog(shell);
    dialog.setOriginalFile(((IFileEditorInput) getEditorInput()).getFile());
    dialog.open();

    IPath path = dialog.getResult();
    if (path != null) {
        // try to save the editor's contents under a different file name
        final IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
        try {
            new ProgressMonitorDialog(shell).run(false, // don't fork
                false, // not cancelable
                new WorkspaceModifyOperation() { // run this operation
                    public void execute(final IProgressMonitor monitor) {
                        try {
                            ByteArrayOutputStream out = new ByteArrayOutputStream();
                            createOutputStream(out);
                            file.create(new ByteArrayInputStream(out.toByteArray()), // contents
                                true, // keep saving, even if IFile
                                        // is out of sync with the
                                        // Workspace
                                monitor); // progress monitor
                        } catch (CoreException ce) {
                            ce.printStackTrace();
                        } catch (IOException ioe) {
                            ioe.printStackTrace();
                        }
                    }
                });
            // set input to the new file
            setInput(new FileEditorInput(file));
            getCommandStack().markSaveLocation();
        } catch (InterruptedException ie) {
            // should not happen, since the monitor dialog is not cancelable
            ie.printStackTrace();
        } catch (InvocationTargetException ite) {
            ite.printStackTrace();
        }
    }
}

public void doSaveAs() {
    // Show a SaveAs dialog
    Shell shell = getSite().getWorkbenchWindow().getShell();
    SaveAsDialog dialog = new SaveAsDialog(shell);
    dialog.setOriginalFile(((IFileEditorInput) getEditorInput()).getFile());
    dialog.open();

    IPath path = dialog.getResult();
    if (path != null) {
        // try to save the editor's contents under a different file name
        final IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
        try {
            new ProgressMonitorDialog(shell).run(false, // don't fork
                false, // not cancelable
                new WorkspaceModifyOperation() { // run this operation
                    public void execute(final IProgressMonitor monitor) {
                        try {
                            ByteArrayOutputStream out = new ByteArrayOutputStream();
                            createOutputStream(out);
                            file.create(new ByteArrayInputStream(out.toByteArray()), // contents
                                true, // keep saving, even if IFile
                                        // is out of sync with the
                                        // Workspace
                                monitor); // progress monitor
                        } catch (CoreException ce) {
                            ce.printStackTrace();
                        } catch (IOException ioe) {
                            ioe.printStackTrace();
                        }
                    }
                });
            // set input to the new file
            setInput(new FileEditorInput(file));
            getCommandStack().markSaveLocation();
        } catch (InterruptedException ie) {
            // should not happen, since the monitor dialog is not cancelable
            ie.printStackTrace();
        } catch (InvocationTargetException ite) {
            ite.printStackTrace();
        }
    }
}