@Override
  public void launch(
      final ILaunchConfiguration config,
      final String mode,
      final ILaunch launch,
      final IProgressMonitor monitor)
      throws CoreException {
    final int WORK_LAUNCH = 10;
    final int WORK_POST_LAUNCH = 100;
    SubMonitor subMonitor = SubMonitor.convert(monitor, WORK_LAUNCH + WORK_POST_LAUNCH);

    // Validate all XML before doing anything else
    final SoftPkg spd = SpdLauncherUtil.getSpd(config);
    IStatus status = SpdLauncherUtil.validateAllXML(spd);
    if (!status.isOK()) {
      throw new CoreException(status);
    }

    final ILaunchConfigurationWorkingCopy copy = config.getWorkingCopy();
    insertProgramArguments(spd, launch, copy);

    try {
      super.launch(copy, mode, launch, subMonitor.newChild(WORK_LAUNCH));
      SpdLauncherUtil.postLaunch(spd, copy, mode, launch, subMonitor.newChild(WORK_POST_LAUNCH));
    } finally {
      if (monitor != null) {
        monitor.done();
      }
    }
  }
  /**
   * Creates a new project resource with the selected name.
   *
   * <p>In normal usage, this method is invoked after the user has pressed Finish on the wizard; the
   * enablement of the Finish button implies that all controls on the pages currently contain valid
   * values.
   *
   * <p>Note that this wizard caches the new project once it has been successfully created;
   * subsequent invocations of this method will answer the same project resource without attempting
   * to create it again.
   *
   * @param monitor TODO
   * @return the created project resource, or <code>null</code> if the project was not created
   */
  protected IProject createNewProject(IProgressMonitor monitor) throws InvocationTargetException {
    SubMonitor sub = SubMonitor.convert(monitor, 100);
    // Project description creation
    IProjectDescription description =
        ResourceUtil.getProjectDescription(destPath, getProjectNatures(), getProjectBuilders());
    description.setName(newProject.getName());
    description.setLocationURI(location);
    // Update the referenced project in case it was initialized.
    if (refProjects != null && refProjects.length > 0) {
      description.setReferencedProjects(refProjects);
    }
    sub.worked(10);

    if (!applySourcedProjectFilesAfterProjectCreated() && isCloneFromGit()) {
      cloneFromGit(newProject, description, sub.newChild(90));
    } else {
      doBasicCreateProject(newProject, description, sub.newChild(75));
      if (!applySourcedProjectFilesAfterProjectCreated()
          && selectedTemplate != null
          && !isCloneFromGit()) {
        selectedTemplate.apply(newProject, true);
      }
    }

    return newProject;
  }
Esempio n. 3
0
  /**
   * Produces a graph depicting the old and new and the delta between them. Output is in SVG format.
   *
   * @param catalogName The name to generate as title in the graph. May be <code>null</code>
   * @param oldCatalogSream
   * @param newCatalogStream
   * @param svgStream
   * @param monitor
   * @param root - the root for files listed as source files in the catalog
   */
  public void produceSVGDeltaGraph(
      String catalogName,
      InputStream oldCatalogStream,
      IPath oldRoot,
      InputStream newCatalogStream,
      IPath newRoot,
      OutputStream svgStream,
      IProgressMonitor monitor)
      throws IOException {
    final SubMonitor ticker = SubMonitor.convert(monitor, 2000);
    CatalogDeltaGraphProducer graphProducer = new CatalogDeltaGraphProducer(hrefProducer, prefix);
    Catalog oldCatalog = CatalogJsonSerializer.load(oldCatalogStream);
    Catalog newCatalog = CatalogJsonSerializer.load(newCatalogStream);

    ICancel cancel =
        new ProgressMonitorCancelIndicator(ticker.newChild(IProgressMonitor.UNKNOWN), 1000);

    ByteArrayOutputStream2 out = new ByteArrayOutputStream2();

    graphProducer.produceGraph(cancel, catalogName, oldCatalog, oldRoot, newCatalog, newRoot, out);
    graphProducer
        .getSVGProducer()
        .produceSVG(
            out.toInputStream(false),
            svgStream,
            false, //
            ticker.newChild(IProgressMonitor.UNKNOWN));
  }
  /**
   * Performs a git clone to a temporary location and then copies the files over top the already
   * generated project. This is because git cannot clone into an existing directory.
   *
   * @param monitor
   * @throws Exception
   */
  protected void cloneAfter(IProgressMonitor monitor) throws Exception {
    SubMonitor sub =
        SubMonitor.convert(monitor, Messages.AbstractNewProjectWizard_CloningFromGitMsg, 100);
    // clone to tmp dir then copy files over top the project!
    File tmpFile = File.createTempFile("delete_me", "tmp"); // $NON-NLS-1$ //$NON-NLS-2$
    File dest = new File(tmpFile.getParent(), "git_clone_tmp"); // $NON-NLS-1$
    GitExecutable.instance()
        .clone(
            selectedTemplate.getLocation(),
            Path.fromOSString(dest.getAbsolutePath()),
            true,
            sub.newChild(85));

    IFileStore tmpClone = EFS.getStore(dest.toURI());
    // Wipe the .git folder before copying? Wipe the .project file before copying?
    IFileStore dotGit = tmpClone.getChild(".git"); // $NON-NLS-1$
    dotGit.delete(EFS.NONE, sub.newChild(2));

    IFileStore dotProject = tmpClone.getChild(IProjectDescription.DESCRIPTION_FILE_NAME);
    if (dotProject.fetchInfo().exists()) {
      dotProject.delete(EFS.NONE, sub.newChild(1));
    }
    // OK, copy the cloned template's contents over
    IFileStore projectStore = EFS.getStore(newProject.getLocationURI());
    tmpClone.copy(projectStore, EFS.OVERWRITE, sub.newChild(9));
    // Now get rid of the temp clone!
    tmpClone.delete(EFS.NONE, sub.newChild(3));
    sub.done();
  }
Esempio n. 5
0
  private void buildFile(
      BuildContext context, List<IBuildParticipant> participants, IProgressMonitor monitor)
      throws CoreException {
    if (CollectionsUtil.isEmpty(participants)) {
      return;
    }

    SubMonitor sub = SubMonitor.convert(monitor, 2 * participants.size());
    for (IBuildParticipant participant : participants) {
      long startTime = System.nanoTime();
      participant.buildFile(context, sub.newChild(1));
      if (traceParticipantsEnabled) {
        double endTime = ((double) System.nanoTime() - startTime) / 1000000;
        IdeLog.logTrace(
            BuildPathCorePlugin.getDefault(),
            MessageFormat.format(
                "Executed build participant ''{0}'' on ''{1}'' in {2} ms.",
                participant.getName(), context.getURI(), endTime),
            IDebugScopes.BUILDER_PARTICIPANTS); // $NON-NLS-1$
      }

      // stop building if it has been canceled
      if (sub.isCanceled()) {
        break;
      }
    }
    updateMarkers(context, sub.newChild(participants.size()));
    sub.done();
  }
  /**
   * Install selected features in to developer studio. Note: call {@link
   * #setSelectedFeaturesToInstall(List) setSelectedFeaturesToInstall} first.
   *
   * @param monitor
   */
  public void installSelectedFeatures(IProgressMonitor monitor) {
    SubMonitor progress = SubMonitor.convert(monitor, Messages.UpdateManager_32, 2);

    URI[] repos = new URI[] {getDevStudioReleaseSite()};
    session = new ProvisioningSession(p2Agent);
    installOperation = new InstallOperation(session, selectedFeatures);
    installOperation.getProvisioningContext().setArtifactRepositories(repos);
    installOperation.getProvisioningContext().setMetadataRepositories(repos);
    IStatus status = installOperation.resolveModal(progress.newChild(1));
    if (status.getSeverity() == IStatus.CANCEL || progress.isCanceled()) {
      throw new OperationCanceledException();
    } else if (status.getSeverity() == IStatus.ERROR) {
      String message = status.getChildren()[0].getMessage();
      log.error(Messages.UpdateManager_33 + message);
    } else {
      ProvisioningJob provisioningJob = installOperation.getProvisioningJob(progress.newChild(1));
      if (provisioningJob != null) {
        provisioningJob.addJobChangeListener(
            new JobChangeAdapter() {
              @Override
              public void done(IJobChangeEvent arg0) {
                Display.getDefault()
                    .syncExec(
                        new Runnable() {
                          @Override
                          public void run() {
                            boolean restart =
                                MessageDialog.openQuestion(
                                    Display.getDefault().getActiveShell(),
                                    Messages.UpdateManager_34,
                                    Messages.UpdateManager_35 + Messages.UpdateManager_36);
                            if (restart) {
                              PlatformUI.getWorkbench().restart();
                            }
                          }
                        });
              }
            });
        provisioningJob.schedule();
        Display.getDefault()
            .syncExec(
                new Runnable() {
                  @Override
                  public void run() {
                    try {
                      PlatformUI.getWorkbench()
                          .getActiveWorkbenchWindow()
                          .getActivePage()
                          .showView(IProgressConstants.PROGRESS_VIEW_ID);
                    } catch (PartInitException e) {
                      log.error(e);
                    }
                  }
                });
      } else {
        log.error(Messages.UpdateManager_37);
      }
    }
  }
 /**
  * Standard impl of restart justc alls stop and then start. Subclasses should override if there's
  * a quicker implementation.
  */
 public IStatus restart(String mode, IProgressMonitor monitor) {
   SubMonitor sub = SubMonitor.convert(monitor, 100);
   IStatus status = stop(true, sub.newChild(30));
   if (!status.isOK()) {
     return status;
   }
   return start(mode, sub.newChild(70));
 }
  private Map<String, EnhancedFeature> loadWSO2FeaturesInRepo(
      IArtifactRepository artifactRepository,
      IQueryResult<IInstallableUnit> allAvailableIUs,
      IProgressMonitor monitor)
      throws ProvisionException, URISyntaxException, IOException {
    if (monitor == null) {
      monitor = new NullProgressMonitor();
    }
    SubMonitor progress = SubMonitor.convert(monitor, Messages.UpdateManager_15, 10);

    String tmpRoot = System.getProperty(JAVA_IO_TMPDIR) + File.separator + DEVS_UPDATER_TMP;

    Collection<IInstallableUnit> wso2FeatureJars =
        filterInstallableUnits(
            WSO2_FEATURE_PREFIX, FEATURE_JAR_IU_ID_SFX, allAvailableIUs, progress.newChild(1));

    Map<String, EnhancedFeature> loadedFeatureMap = new HashMap<>();

    for (IInstallableUnit iu : wso2FeatureJars) {
      SubMonitor downloadProgress =
          SubMonitor.convert(progress, Messages.UpdateManager_16, wso2FeatureJars.size() * 2);
      Collection<IArtifactKey> artifacts = iu.getArtifacts();
      // ideally there should be only one artifact in a feature.jar iu
      for (IArtifactKey iArtifactKey : artifacts) {
        IArtifactDescriptor[] artifactDescriptors =
            artifactRepository.getArtifactDescriptors(iArtifactKey);
        File featureCacheRoot =
            new File(tmpRoot, iu.getId() + File.separator + iu.getVersion().toString());
        File cachedFeatureDir = new File(featureCacheRoot, FEATURE_JAR_EXTRCT_FOLDER);

        if (cachedFeatureDir.exists() && cachedFeatureDir.isDirectory()) {
          downloadProgress.worked(2);
        } else {
          featureCacheRoot.mkdirs();
          File jarFile = new File(featureCacheRoot, iu.getId());
          try {
            if (jarFile.exists()) {
              // something is wrong with the file
              // if it is there without the cache dir.
              jarFile.delete();
            }
            FileOutputStream fop = new FileOutputStream(jarFile);
            // jar iu only contains a single artifact. hence [0]
            artifactRepository.getArtifact(
                artifactDescriptors[0], fop, downloadProgress.newChild(1));
            cachedFeatureDir.mkdirs();
            extractJar(jarFile, cachedFeatureDir);
            downloadProgress.worked(1);
          } catch (IOException e) {
            throw new IOException(Messages.UpdateManager_17, e);
          }
        }
        EnhancedFeature feature = readEnhancedMetadata(iu, cachedFeatureDir);
        loadedFeatureMap.put(feature.getId(), feature);
      }
    }
    return loadedFeatureMap;
  }
Esempio n. 9
0
  @SuppressWarnings("rawtypes")
  @Override
  protected IProject[] build(int kind, Map args, IProgressMonitor monitor) throws CoreException {
    traceParticipantsEnabled =
        IdeLog.isTraceEnabled(BuildPathCorePlugin.getDefault(), IDebugScopes.BUILDER_PARTICIPANTS);

    boolean logTraceEnabled = traceLoggingEnabled();

    IProject project = getProjectHandle();
    String projectName = project.getName();
    long startTime = System.nanoTime();

    SubMonitor sub = SubMonitor.convert(monitor, 100);

    // Keep these build participant instances and use them in the build process, rather than
    // grabbing new ones
    // in sub-methods. We do pre- and post- setups on them, so we need to retain instances.
    IBuildParticipantManager manager = getBuildParticipantManager();
    if (manager == null) {
      return new IProject[0];
    }
    List<IBuildParticipant> participants = manager.getAllBuildParticipants();
    participants = filterToEnabled(participants, project);
    buildStarting(participants, kind, sub.newChild(10));

    if (kind == IncrementalProjectBuilder.FULL_BUILD) {
      if (logTraceEnabled) {
        logTrace(MessageFormat.format(Messages.UnifiedBuilder_PerformingFullBuld, projectName));
      }
      fullBuild(participants, sub.newChild(80));
    } else {
      IResourceDelta delta = getResourceDelta();
      if (delta == null) {
        if (logTraceEnabled) {
          logTrace(
              MessageFormat.format(
                  Messages.UnifiedBuilder_PerformingFullBuildNullDelta, projectName));
        }
        fullBuild(participants, sub.newChild(80));
      } else {
        if (logTraceEnabled) {
          logTrace(
              MessageFormat.format(
                  Messages.UnifiedBuilder_PerformingIncrementalBuild, projectName));
        }
        incrementalBuild(participants, delta, sub.newChild(80));
      }
    }

    buildEnding(participants, sub.newChild(10));

    if (logTraceEnabled) {
      double endTime = ((double) System.nanoTime() - startTime) / 1000000;
      logTrace(MessageFormat.format(Messages.UnifiedBuilder_FinishedBuild, projectName, endTime));
    }
    return null;
  }
  @Override
  public RefactoringStatus checkInitialConditions(final IProgressMonitor monitor)
      throws CoreException {
    final SubMonitor progress = SubMonitor.convert(monitor, 6);
    try {
      if (fSelectionRegion != null) {
        fSourceUnit.connect(progress.newChild(1));
        try {
          final AbstractDocument document = fSourceUnit.getDocument(monitor);

          final IRModelInfo modelInfo =
              (IRModelInfo)
                  fSourceUnit.getModelInfo(
                      RModel.TYPE_ID, IRModelManager.MODEL_FILE, progress.newChild(1));
          if (modelInfo != null) {
            final IRegion region = fAdapter.trimToAstRegion(document, fSelectionRegion);
            ISourceStructElement element =
                LTKUtil.getCoveringSourceElement(modelInfo.getSourceElement(), region);
            while (element != null) {
              if (element instanceof IRMethod) {
                fFunction = (IRMethod) element;
                break;
              }
              element = element.getSourceParent();
            }
          }

          if (fFunction != null) {
            final ISourceStructElement source = (ISourceStructElement) fFunction;
            fOperationRegion =
                fAdapter.expandSelectionRegion(document, source.getSourceRange(), fSelectionRegion);
          }
        } finally {
          fSourceUnit.disconnect(progress.newChild(1));
        }
      }

      if (fFunction == null) {
        return RefactoringStatus.createFatalErrorStatus(
            Messages.FunctionToS4Method_error_InvalidSelection_message);
      }
      final RefactoringStatus result = new RefactoringStatus();
      fAdapter.checkInitialForModification(result, fElementSet);
      progress.worked(1);

      if (result.hasFatalError()) {
        return result;
      }

      checkFunction(result);
      progress.worked(2);
      return result;
    } finally {
      progress.done();
    }
  }
Esempio n. 11
0
  private Collection<IInstallableUnit> getInstalledWSO2Features(IProgressMonitor monitor)
      throws OperationCanceledException {
    SubMonitor progress = SubMonitor.convert(monitor, Messages.UpdateManager_23, 2);

    OperationFactory operationFactory = new OperationFactory();
    IQueryResult<IInstallableUnit> queryResult =
        operationFactory.listInstalledElements(true, progress.newChild(1));
    return filterInstallableUnits(
        WSO2_FEATURE_PREFIX, FEATURE_GROUP_IU_ID_SFX, queryResult, progress.newChild(1));
  }
Esempio n. 12
0
 public void findAllReferences(
     IQueryData queryData,
     ILocalResourceAccess localResourceAccess,
     final IAcceptor<IReferenceDescription> acceptor,
     IProgressMonitor monitor) {
   final SubMonitor subMonitor = SubMonitor.convert(monitor, 2);
   if (!queryData.getTargetURIs().isEmpty()) {
     findLocalReferences(queryData, localResourceAccess, acceptor, subMonitor.newChild(1));
     findIndexedReferences(queryData, acceptor, subMonitor.newChild(1));
   }
 }
Esempio n. 13
0
  /**
   * @param monitor the progress monitor to use for reporting progress to the user. It is the
   *     caller's responsibility to call done() on the given monitor. Accepts null, indicating that
   *     no progress should be reported and that the operation cannot be cancelled.
   */
  protected void fullBuild(final IProgressMonitor monitor, boolean isRecoveryBuild)
      throws CoreException {
    SubMonitor progress = SubMonitor.convert(monitor, 10);

    IProject project = getProject();
    ToBeBuilt toBeBuilt =
        isRecoveryBuild
            ? toBeBuiltComputer.updateProjectNewResourcesOnly(project, progress.newChild(2))
            : toBeBuiltComputer.updateProject(project, progress.newChild(2));
    doBuild(toBeBuilt, progress.newChild(8), isRecoveryBuild ? BuildType.RECOVERY : BuildType.FULL);
  }
  @Override
  public RefactoringStatus checkInitialConditions(final IProgressMonitor monitor)
      throws CoreException {
    final SubMonitor progress = SubMonitor.convert(monitor, 6);
    RAstNode rootNode = null;
    try {
      if (fSelectionRegion != null) {
        fSourceUnit.connect(progress.newChild(1));
        try {
          final AbstractDocument document = fSourceUnit.getDocument(monitor);
          final RHeuristicTokenScanner scanner = fAdapter.getScanner(fSourceUnit);

          final IRModelInfo modelInfo =
              (IRModelInfo)
                  fSourceUnit.getModelInfo(
                      RModel.TYPE_ID, IRModelManager.MODEL_FILE, progress.newChild(1));
          if (modelInfo != null) {
            final IRegion region = fAdapter.trimToAstRegion(document, fSelectionRegion, scanner);
            final AstInfo ast = modelInfo.getAst();
            if (ast != null) {
              rootNode =
                  (RAstNode)
                      AstSelection.search(
                              ast.root,
                              region.getOffset(),
                              region.getOffset() + region.getLength(),
                              AstSelection.MODE_COVERING_SAME_LAST)
                          .getCovering();
            }
          }
        } finally {
          fSourceUnit.disconnect(progress.newChild(1));
        }
      }

      if (rootNode == null) {
        return RefactoringStatus.createFatalErrorStatus(
            Messages.ExtractTemp_error_InvalidSelection_message);
      }
      final RefactoringStatus result = new RefactoringStatus();
      fAdapter.checkInitialToModify(result, fElementSet);
      progress.worked(1);

      if (result.hasFatalError()) {
        return result;
      }

      searchVariables(rootNode, result);
      progress.worked(2);
      return result;
    } finally {
      progress.done();
    }
  }
 /**
  * Creates a new REDHAWK component project without any files. Should be invoked in the context of
  * a {@link org.eclipse.ui.actions.WorkspaceModifyOperation WorkspaceModifyOperation}.
  *
  * @param projectName The project name
  * @param projectLocation the location on disk to create the project
  * @param monitor the progress monitor to use for reporting progress to the user. It is the
  *     caller's responsibility to call done() on the given monitor. Accepts null, indicating that
  *     no progress should be reported and that the operation cannot be canceled.
  * @return The newly created project
  * @throws CoreException A problem occurs while creating the project
  */
 public static IProject createEmptyProject(
     final String projectName, final URI projectLocation, final IProgressMonitor monitor)
     throws CoreException {
   final SubMonitor progress = SubMonitor.convert(monitor, "Creating empty project", 2);
   final String[] additionalNatureIDs =
       new String[] {ScaComponentProjectNature.ID, "org.python.pydev.pythonNature"};
   final IProject project =
       ProjectCreator.createEmptyProject(
           projectName, projectLocation, additionalNatureIDs, progress.newChild(1));
   ProjectCreator.resetProject(project, progress.newChild(1));
   return project;
 }
Esempio n. 16
0
  @Override
  public void build(final IBuildContext context, IProgressMonitor monitor) throws CoreException {
    if (!isEnabled(context)) {
      return;
    }

    final List<IResourceDescription.Delta> deltas = getRelevantDeltas(context);
    if (deltas.isEmpty()) {
      return;
    }

    StoppedTask task =
        Stopwatches.forTask(
            "org.eclipse.xtext.builder.BuilderParticipant.build(IBuildContext, IProgressMonitor)");
    try {
      task.start();

      // monitor handling
      if (monitor.isCanceled()) throw new OperationCanceledException();
      SubMonitor subMonitor =
          SubMonitor.convert(monitor, context.getBuildType() == BuildType.RECOVERY ? 5 : 3);

      EclipseResourceFileSystemAccess2 access = fileSystemAccessProvider.get();
      IProject builtProject = context.getBuiltProject();
      access.setProject(builtProject);
      Map<String, OutputConfiguration> outputConfigurations = getOutputConfigurations(context);
      refreshOutputFolders(context, outputConfigurations, subMonitor.newChild(1));
      if (subMonitor.isCanceled()) {
        throw new OperationCanceledException();
      }
      access.setOutputConfigurations(outputConfigurations);
      if (context.getBuildType() == BuildType.CLEAN
          || context.getBuildType() == BuildType.RECOVERY) {
        SubMonitor cleanMonitor =
            SubMonitor.convert(subMonitor.newChild(2), outputConfigurations.size());
        for (OutputConfiguration config : outputConfigurations.values()) {
          cleanOutput(context, config, access, cleanMonitor.newChild(1));
        }
        if (context.getBuildType() == BuildType.CLEAN) return;
      }
      Map<OutputConfiguration, Iterable<IMarker>> generatorMarkers =
          getGeneratorMarkers(builtProject, outputConfigurations.values());
      if (subMonitor.isCanceled()) {
        throw new OperationCanceledException();
      }
      doBuild(
          deltas, outputConfigurations, generatorMarkers, context, access, subMonitor.newChild(2));

    } finally {
      task.stop();
    }
  }
Esempio n. 17
0
 /**
  * @param monitor the progress monitor to use for reporting progress to the user. It is the
  *     <em>implementors</em> responsibility to call done() on the given monitor. Accepts null,
  *     indicating that no progress should be reported and that the operation cannot be cancelled.
  */
 @Override
 protected void clean(IProgressMonitor monitor) throws CoreException {
   SubMonitor progress = SubMonitor.convert(monitor, 10);
   try {
     ToBeBuilt toBeBuilt = toBeBuiltComputer.removeProject(getProject(), progress.newChild(2));
     if (monitor.isCanceled()) {
       throw new OperationCanceledException();
     }
     doClean(toBeBuilt, progress.newChild(8));
   } finally {
     if (monitor != null) monitor.done();
   }
 }
Esempio n. 18
0
 @Override
 protected void execute(final IProgressMonitor monitor)
     throws CoreException, InvocationTargetException, InterruptedException {
   SubMonitor subMonitor = SubMonitor.convert(monitor, getCreateModelProjectMessage(), 2);
   try {
     final IProject project = createProject(subMonitor.newChild(1));
     if (project == null) return;
     enhanceProject(project, subMonitor.newChild(1));
     IFile modelFile = getModelFile(project);
     setResult(modelFile);
   } finally {
     subMonitor.done();
   }
 }
  private void create_project(
      final String project_path,
      final String lang,
      final String codegenId,
      final String templateId,
      String project_type,
      final IProgressMonitor progressMonitor)
      throws CoreException {
    final SubMonitor monitor = SubMonitor.convert(progressMonitor, 2);
    final IPath projectPath = new Path(project_path);

    if (projectPath.toFile().exists()) {
      throw new CoreException(
          new Status(
              IStatus.ERROR,
              CodegeneratorApplication.PLUGIN_ID,
              "Provided project path must not yet exist",
              null));
    }

    if (lang == null) {
      throw new CoreException(
          new Status(
              IStatus.ERROR,
              CodegeneratorApplication.PLUGIN_ID,
              "You must provide a programming language when creating a new component project",
              null));
    }

    // Clean-up project_type
    if ((project_type == null) || ("resource".equals(project_type))) {
      create_component_project(projectPath, lang, codegenId, templateId, monitor.newChild(1));
    } else if ("device".equals(project_type)) {
      project_type = "device";
      create_device_project(
          projectPath, "Device", lang, codegenId, templateId, monitor.newChild(1));
    } else if ("loadabledevice".equals(project_type)) {
      project_type = "device";
      create_device_project(
          projectPath, "Loadable", lang, codegenId, templateId, monitor.newChild(1));
    } else if ("executabledevice".equals(project_type)) {
      project_type = "device";
      create_device_project(
          projectPath, "Executable", lang, codegenId, templateId, monitor.newChild(1));
    } else {
      throw new CoreException(
          new Status(
              IStatus.ERROR, CodegeneratorApplication.PLUGIN_ID, "Unsupported project type", null));
    }
  }
Esempio n. 20
0
 @Override
 protected IStatus run(IProgressMonitor monitor) {
   final XtextEditor editor = initialEditor;
   final boolean isMarkOccurrences = initialIsMarkOccurrences;
   final ITextSelection selection = initialSelection;
   final SubMonitor progress = SubMonitor.convert(monitor, 2);
   if (!progress.isCanceled()) {
     final Map<Annotation, Position> annotations =
         (isMarkOccurrences)
             ? occurrenceComputer.createAnnotationMap(editor, selection, progress.newChild(1))
             : Collections.<Annotation, Position>emptyMap();
     if (!progress.isCanceled()) {
       Display.getDefault()
           .asyncExec(
               new Runnable() {
                 public void run() {
                   if (!progress.isCanceled()) {
                     final IAnnotationModel annotationModel = getAnnotationModel(editor);
                     if (annotationModel instanceof IAnnotationModelExtension)
                       ((IAnnotationModelExtension) annotationModel)
                           .replaceAnnotations(
                               getExistingOccurrenceAnnotations(annotationModel), annotations);
                     else if (annotationModel != null)
                       throw new IllegalStateException(
                           "AnnotationModel does not implement IAnnotationModelExtension"); //$NON-NLS-1$
                   }
                 }
               });
     }
   }
   return progress.isCanceled() ? Status.CANCEL_STATUS : Status.OK_STATUS;
 }
Esempio n. 21
0
 private void compileFiles(BuildContext[] contexts, IProgressMonitor monitor)
     throws CoreException {
   SubMonitor sub =
       SubMonitor.convert(monitor, "Analyzing Files...", fParticipants.length + contexts.length);
   if (fParticipants != null) {
     for (int i = 0; i < fParticipants.length; i++) {
       if (monitor.isCanceled()) throw new OperationCanceledException();
       try {
         long start = System.currentTimeMillis();
         fParticipants[i].buildStarting(contexts, true, sub.newChild(1));
         if (RubyBuilder.DEBUG)
           System.out.println(
               fParticipants[i].getClass().getSimpleName()
                   + " took "
                   + (System.currentTimeMillis() - start)
                   + "ms");
       } catch (Exception e) {
         RubyCore.log(e);
       }
     }
   }
   for (int i = 0; i < contexts.length; i++) {
     CategorizedProblem[] problems = contexts[i].getProblems();
     if (problems == null || problems.length == 0) {
       sub.worked(1);
       continue;
     }
     for (int j = 0; j < problems.length; j++) {
       markerManager.addProblem(contexts[i].getFile(), problems[j]);
     }
     sub.worked(1);
   }
   sub.done();
 }
Esempio n. 22
0
  private void buildFiles(
      List<IBuildParticipant> participants, Collection<IFile> files, IProgressMonitor monitor)
      throws CoreException {
    if (CollectionsUtil.isEmpty(participants) || CollectionsUtil.isEmpty(files)) {
      return;
    }
    SubMonitor sub = SubMonitor.convert(monitor, 100);

    // Filter
    files = filterFiles(files, sub.newChild(10));

    // Then build
    doBuildFiles(participants, files, sub.newChild(90));

    sub.done();
  }
Esempio n. 23
0
  private void doBuildFiles(
      List<IBuildParticipant> participants, Collection<IFile> files, IProgressMonitor monitor)
      throws CoreException {
    if (CollectionsUtil.isEmpty(files)) {
      return;
    }

    SubMonitor sub = SubMonitor.convert(monitor, 15 * files.size());
    for (IFile file : files) {
      BuildContext context = new BuildContext(file);
      sub.worked(1);

      IBuildParticipantManager manager = getBuildParticipantManager();
      if (manager == null) {
        return;
      }
      List<IBuildParticipant> filteredParticipants =
          manager.filterParticipants(participants, context.getContentType());
      sub.worked(2);

      buildFile(context, filteredParticipants, sub.newChild(12));

      // stop building if canceled
      if (sub.isCanceled()) {
        break;
      }
    }
    sub.done();
  }
  @Override
  public List<Object> computeContext(
      IInteractionContext context, IAdaptable input, IProgressMonitor monitor) {
    if (delegates == null || delegates.isEmpty()) {
      return Collections.emptyList();
    }
    List<Object> objects = new ArrayList<Object>();

    SubMonitor progress = SubMonitor.convert(monitor);
    int workPerDelegate = 1000;
    progress.beginTask(
        Messages.CompoundContextComputationStrategy_Computing_Context_Task_Label,
        delegates.size() * workPerDelegate);
    try {
      for (ContextComputationStrategy delegate : delegates) {
        if (progress.isCanceled()) {
          break;
        }
        objects.addAll(delegate.computeContext(context, input, progress.newChild(workPerDelegate)));
      }
    } finally {
      progress.done();
    }

    return objects;
  }
Esempio n. 25
0
  @Override
  protected void clean(IProgressMonitor monitor) throws CoreException {
    super.clean(monitor);

    IProject project = getProjectHandle();

    IBuildParticipantManager manager = getBuildParticipantManager();
    if (manager == null) {
      return;
    }
    List<IBuildParticipant> participants = manager.getAllBuildParticipants();
    participants = filterToEnabled(participants, project);

    SubMonitor sub = SubMonitor.convert(monitor, participants.size() + 2);
    sub.worked(1);

    removeProblemsAndTasksFor(project);
    sub.worked(1);

    // FIXME Should we visit all files and call "deleteFile" sort of like what we do with fullBuild?
    for (IBuildParticipant participant : participants) {
      if (sub.isCanceled()) {
        return;
      }

      participant.clean(project, sub.newChild(1));
    }
    sub.done();
  }
  /** This method is extremely expensive. */
  @OnEclipseVersionUpgrade("Replace monitor.newChild(1) by monitor.split(1)")
  private boolean isMethodUsedInItsPackage(IMethodBinding methodBinding, MethodDeclaration node) {
    final IPackageBinding methodPackage = methodBinding.getDeclaringClass().getPackage();

    final AtomicBoolean methodIsUsedInPackage = new AtomicBoolean(false);
    final SearchRequestor requestor =
        new SearchRequestor() {
          @Override
          public void acceptSearchMatch(SearchMatch match) {
            methodIsUsedInPackage.set(true);
          }
        };

    final SubMonitor subMonitor = SubMonitor.convert(ctx.getProgressMonitor(), 1);
    final SubMonitor childMonitor = subMonitor.newChild(1);
    try {
      final SearchEngine searchEngine = new SearchEngine();
      searchEngine.search(
          createPattern(methodBinding.getJavaElement(), REFERENCES, R_EXACT_MATCH),
          new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
          SearchEngine.createJavaSearchScope(new IJavaElement[] {methodPackage.getJavaElement()}),
          requestor,
          childMonitor);
      return methodIsUsedInPackage.get();
    } catch (CoreException e) {
      throw new UnhandledException(node, e);
    } finally {
      childMonitor.done();
    }
  }
Esempio n. 27
0
  @Override
  public IStatus execute(final IProgressMonitor monitor)
      throws CoreException, InvocationTargetException {
    final SubMonitor progress =
        SubMonitor.convert(
            monitor,
            Messages.getString("org.kalypso.model.flood.ui.map.operations.ImportTinOperation.0"),
            100); //$NON-NLS-1$

    /* Add sources as new tin references */
    progress.subTask(
        Messages.getString(
            "org.kalypso.model.flood.ui.map.operations.ImportTinOperation.1")); //$NON-NLS-1$
    m_tinRefs = new ITinReference[m_sources.length];
    final Feature[] changedFeatures = new Feature[m_sources.length];

    for (int i = 0; i < m_sources.length; i++) {
      final IGmlSource source = m_sources[i];

      final ITinReference tinRef = m_tins.addNew(-1, ITinReference.QNAME, ITinReference.class);
      tinRef.setName(source.getName());
      tinRef.setDescription(source.getDescription());
      tinRef.setSourceLocation(source.getLocation());
      tinRef.setSourceFeaturePath(source.getPath());
      tinRef.setSourceType(typeForSource(source));

      m_tinRefs[i] = tinRef;
      changedFeatures[i] = tinRef;
    }
    ProgressUtilities.worked(progress, 20);

    /* post command for events stuff... */
    final Feature parentFeature = m_tins.getParentFeature();
    final GMLWorkspace workspace = parentFeature.getWorkspace();
    final ModellEvent modelEvent =
        new FeatureStructureChangeModellEvent(
            workspace,
            parentFeature,
            changedFeatures,
            FeatureStructureChangeModellEvent.STRUCTURE_CHANGE_ADD);
    workspace.fireModellEvent(modelEvent);
    /* Save data model */
    // progress.subTask( "speichere Datenmodell" );
    // m_provider.saveModel( IFloodModel.class, progress.newChild( 20 ) );
    /* update tins */
    progress.subTask(
        Messages.getString(
            "org.kalypso.model.flood.ui.map.operations.ImportTinOperation.2")); //$NON-NLS-1$
    final UpdateTinsOperation updateOp = new UpdateTinsOperation(m_tinRefs, m_provider);
    updateOp.execute(progress.newChild(60));

    /* Jump to imported tins */
    final GM_Envelope envelope = FeatureHelper.getEnvelope(changedFeatures);
    final GM_Envelope scaledBox =
        envelope == null ? null : GeometryUtilities.scaleEnvelope(envelope, 1.05);
    if (m_mapPanel != null && scaledBox != null) m_mapPanel.setBoundingBox(scaledBox);

    return Status.OK_STATUS;
  }
Esempio n. 28
0
 /**
  * Run a refresh synchronously. FIXME Should this even be visible to callers? We should pick up
  * file events via watcher to refresh whenever we really need to. This should become default
  * visibility.
  *
  * @param monitor
  * @return
  */
 public IStatus refresh(IProgressMonitor monitor) {
   SubMonitor sub = SubMonitor.convert(monitor, 100);
   try {
     return refresh(true, null, sub.newChild(100));
   } finally {
     sub.done();
   }
 }
 private List<String> createChanges(final TextFileChange change, final SubMonitor progress)
     throws BadLocationException {
   final List<String> names = new ArrayList<String>();
   int remaining = fVariablesList.size() + 3;
   progress.setWorkRemaining(remaining);
   remaining -= 3;
   fSourceUnit.connect(progress.newChild(2));
   try {
     for (final Map<String, Variable> frameList : fVariablesList.values()) {
       progress.setWorkRemaining(remaining--);
       createMainChanges(frameList, change, names);
     }
     return names;
   } finally {
     fSourceUnit.disconnect(progress.newChild(1));
   }
 }
Esempio n. 30
0
 /**
  * Scans the specified source {@linkplain CompilationUnit} for contributed API javadoc tags. Tags
  * on methods will have unresolved signatures.
  *
  * @param source the source file to scan for tags
  * @param description the API description to annotate with any new tag rules found
  * @param container optional class file container containing the class file for the given source
  *     that can be used to resolve method signatures if required (for tags on methods). If not
  *     provided (<code>null</code>), method signatures will be unresolved.
  * @param options a map of Java compiler options to use when creating the AST to scan or <code>
  *     null</code> if default options should be used
  * @param monitor
  * @throws CoreException
  */
 public void scan(
     CompilationUnit source,
     IApiDescription description,
     IApiTypeContainer container,
     Map options,
     IProgressMonitor monitor)
     throws CoreException {
   SubMonitor localmonitor = SubMonitor.convert(monitor, 2);
   ASTParser parser = ASTParser.newParser(AST.JLS3);
   InputStream inputStream = null;
   try {
     inputStream = source.getInputStream();
     parser.setSource(
         Util.getInputStreamAsCharArray(
             inputStream, -1, System.getProperty("file.encoding"))); // $NON-NLS-1$
   } catch (FileNotFoundException e) {
     throw new CoreException(
         new Status(
             IStatus.ERROR,
             ApiPlugin.PLUGIN_ID,
             MessageFormat.format(
                 "Compilation unit source not found: {0}", new String[] {source.getName()}),
             e)); //$NON-NLS-1$
   } catch (IOException e) {
     if (DEBUG) {
       System.err.println(source.getName());
     }
     throw new CoreException(
         new Status(
             IStatus.ERROR,
             ApiPlugin.PLUGIN_ID,
             MessageFormat.format(
                 "Error reading compilation unit: {0}", new String[] {source.getName()}),
             e)); //$NON-NLS-1$
   } finally {
     if (inputStream != null) {
       try {
         inputStream.close();
       } catch (IOException e) {
         ApiPlugin.log(e);
       }
     }
   }
   Util.updateMonitor(localmonitor);
   Map loptions = options;
   if (loptions == null) {
     loptions = JavaCore.getOptions();
   }
   loptions.put(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, JavaCore.ENABLED);
   parser.setCompilerOptions(loptions);
   org.eclipse.jdt.core.dom.CompilationUnit cunit =
       (org.eclipse.jdt.core.dom.CompilationUnit) parser.createAST(localmonitor.newChild(1));
   Visitor visitor = new Visitor(description, container);
   cunit.accept(visitor);
   if (visitor.getException() != null) {
     throw visitor.getException();
   }
 }