コード例 #1
0
  protected void handleAdd() {
    ElementListSelectionDialog dialog =
        new ElementListSelectionDialog(getShell(), new StyledBundleLabelProvider(false, false));

    try {
      dialog.setElements(getValidBundles());
    } catch (CoreException e) {
      dialog.setMessage(e.getMessage());
    }

    dialog.setTitle(PDEUIMessages.PluginSelectionDialog_title);
    dialog.setMessage(PDEUIMessages.PluginSelectionDialog_message);
    dialog.setMultipleSelection(true);
    if (dialog.open() == Window.OK) {

      Object[] models = dialog.getResult();
      ArrayList<NameVersionDescriptor> pluginsToAdd = new ArrayList<NameVersionDescriptor>();
      for (int i = 0; i < models.length; i++) {
        BundleInfo desc = ((BundleInfo) models[i]);
        pluginsToAdd.add(new NameVersionDescriptor(desc.getSymbolicName(), null));
      }
      Set<NameVersionDescriptor> allDependencies = new HashSet<NameVersionDescriptor>();
      allDependencies.addAll(pluginsToAdd);
      NameVersionDescriptor[] currentBundles = getTargetDefinition().getImplicitDependencies();
      if (currentBundles != null) {
        allDependencies.addAll(Arrays.asList(currentBundles));
      }
      getTargetDefinition()
          .setImplicitDependencies(
              allDependencies.toArray(new NameVersionDescriptor[allDependencies.size()]));
      fElementViewer.refresh();
      updateImpButtons();
    }
  }
コード例 #2
0
  private void handleSetImportSelection(ArrayList<Object> newSelectionList) {
    if (newSelectionList.size() == 0) {
      handleRemoveAll();
      pageChanged();
      return;
    }
    TableItem[] items = fImportListViewer.getTable().getItems();
    Object[] oldSelection = new Object[items.length];
    for (int i = 0; i < items.length; i++) {
      oldSelection[i] = items[i].getData();
    }

    // remove items that were in the old selection, but are not in the new one
    List<Object> itemsToRemove = new ArrayList<>();
    for (int i = 0; i < oldSelection.length; i++) {
      if (newSelectionList.contains(oldSelection[i])) {
        newSelectionList.remove(oldSelection[i]);
      } else {
        itemsToRemove.add(oldSelection[i]);
      }
    }
    doRemove(itemsToRemove);

    // add items that were not in the old selection and are in the new one
    doAdd(newSelectionList);

    pageChanged();
  }
コード例 #3
0
 /**
  * Recursively gets the ID of required features of this feature and adds them to the list
  *
  * @param model feature model to get requirements of
  * @param requiredFeatureList collector for the required features
  */
 private void getFeatureDependencies(
     IFeatureModel model, IFeatureModel[] allFeatures, ArrayList requiredFeatureList) {
   IFeature feature = model.getFeature();
   IFeatureImport[] featureImports = feature.getImports();
   for (int i = 0; i < featureImports.length; i++) {
     if (featureImports[i].getType() == IFeatureImport.FEATURE) {
       for (int j = 0; j < allFeatures.length; j++) {
         if (allFeatures[j].getFeature().getId().equals(featureImports[i].getId())) {
           requiredFeatureList.add(allFeatures[j]);
           getFeatureDependencies(allFeatures[j], allFeatures, requiredFeatureList);
           break;
         }
       }
     }
   }
   IFeatureChild[] featureIncludes = feature.getIncludedFeatures();
   for (int i = 0; i < featureIncludes.length; i++) {
     requiredFeatureList.add(featureIncludes[i].getId());
     for (int j = 0; j < allFeatures.length; j++) {
       if (allFeatures[j].getFeature().getId().equals(featureIncludes[i].getId())) {
         requiredFeatureList.add(allFeatures[j]);
         getFeatureDependencies(allFeatures[j], allFeatures, requiredFeatureList);
         break;
       }
     }
   }
 }
コード例 #4
0
 /**
  * Uses the feature model to determine the set of features required by the given list of checked
  * features
  *
  * @param allFeatures list of all features to search requirements in
  * @param checkedFeatures list of features to get requirements for
  * @return list of features to be checked
  */
 private Object[] getRequiredFeatures(
     final IFeatureModel[] allFeatures, final Object[] checkedFeatures) {
   ArrayList required = new ArrayList();
   for (int j = 0; j < checkedFeatures.length; j++) {
     if (checkedFeatures[j] instanceof IFeatureModel) {
       getFeatureDependencies((IFeatureModel) checkedFeatures[j], allFeatures, required);
     }
   }
   return required.toArray();
 }
コード例 #5
0
 private void handleExistingProjects() {
   ArrayList<Object> result = new ArrayList<>();
   for (int i = 0; i < fModels.length; i++) {
     String id = fModels[i].getPluginBase().getId();
     IProject project = (IProject) PDEPlugin.getWorkspace().getRoot().findMember(id);
     if (project != null && project.isOpen() && WorkspaceModelManager.isPluginProject(project)) {
       result.add(fModels[i]);
     }
   }
   handleSetImportSelection(result);
 }
コード例 #6
0
  private void handleAddAll() {
    TableItem[] items = fAvailableListViewer.getTable().getItems();

    ArrayList<Object> data = new ArrayList<>();
    for (int i = 0; i < items.length; i++) {
      data.add(items[i].getData());
    }
    if (data.size() > 0) {
      doAdd(data);
      pageChanged(true, false);
    }
  }
コード例 #7
0
  private void handleRemoveAll() {
    TableItem[] items = fImportListViewer.getTable().getItems();

    ArrayList<Object> data = new ArrayList<>();
    for (int i = 0; i < items.length; i++) {
      data.add(items[i].getData());
    }
    if (data.size() > 0) {
      doRemove(data);
      pageChanged(false, true);
    }
  }
 private void computeUnmigrated() {
   IPluginModelBase[] models = PluginRegistry.getWorkspaceModels();
   ArrayList<IPluginModelBase> modelArray = new ArrayList<IPluginModelBase>();
   try {
     for (int i = 0; i < models.length; i++) {
       if (models[i].getUnderlyingResource().getProject().hasNature(JavaCore.NATURE_ID))
         modelArray.add(models[i]);
     }
   } catch (CoreException e) {
     PDEPlugin.logException(e);
   }
   fUnmigrated = modelArray.toArray(new IPluginModelBase[modelArray.size()]);
 }
コード例 #9
0
 public Object[] getElements(Object inputElement) {
   // model = (ISite) inputElement;
   ArrayList<IWritable> result = new ArrayList<IWritable>();
   ISiteCategoryDefinition[] catDefs = fModel.getSite().getCategoryDefinitions();
   for (int i = 0; i < catDefs.length; i++) {
     result.add(catDefs[i]);
   }
   ISiteFeature[] features = fModel.getSite().getFeatures();
   for (int i = 0; i < features.length; i++) {
     if (features[i].getCategories().length == 0)
       result.add(new SiteFeatureAdapter(null, features[i]));
   }
   return result.toArray();
 }
コード例 #10
0
 protected static void setOrdered(IdMap idmap, ArrayList idmapOrdered) {
   ArrayList Ordered = new ArrayList();
   for (Iterator iter_ordered = idmapOrdered.iterator(); iter_ordered.hasNext(); ) {
     Mapping mapping = new Mapping();
     String signature = (String) iter_ordered.next();
     int end_of_signature = signature.lastIndexOf(SIGN_SEPARATOR, signature.length() - 2);
     if (end_of_signature < XMLStructureCreator.ROOT_ID.length() + 1)
       mapping.setSignature(""); // $NON-NLS-1$
     else
       mapping.setSignature(
           signature.substring(XMLStructureCreator.ROOT_ID.length() + 1, end_of_signature));
     mapping.setElement(signature.substring(end_of_signature + 1, signature.length() - 1));
     Ordered.add(mapping);
   }
   idmap.setOrdered(Ordered);
 }
コード例 #11
0
 private ISiteFeature[] getFeaturesFromSelection(IStructuredSelection sel) {
   if (sel.isEmpty()) return new ISiteFeature[0];
   if (cachedSelection == sel) return cachedFeatures;
   cachedSelection = sel;
   ArrayList<ISiteFeature> features = new ArrayList<ISiteFeature>(sel.size());
   Iterator<?> iterator = sel.iterator();
   while (iterator.hasNext()) {
     Object next = iterator.next();
     if (next instanceof SiteFeatureAdapter) {
       if ((((SiteFeatureAdapter) next).feature) != null) {
         features.add(((SiteFeatureAdapter) next).feature);
       }
     }
   }
   cachedFeatures = features.toArray(new ISiteFeature[features.size()]);
   return cachedFeatures;
 }
コード例 #12
0
  private void handleAddRequiredPlugins() {
    TableItem[] items = fImportListViewer.getTable().getItems();
    if (items.length == 0) return;
    if (items.length == 1) {
      IPluginModelBase model = (IPluginModelBase) items[0].getData();
      if (model.getPluginBase().getId().equals("org.eclipse.core.boot")) { // $NON-NLS-1$
        return;
      }
    }

    ArrayList<IPluginModelBase> result = new ArrayList<>();
    for (int i = 0; i < items.length; i++) {
      addPluginAndDependencies(
          (IPluginModelBase) items[i].getData(), result, fAddFragmentsButton.getSelection());
    }
    ArrayList<Object> resultObject = new ArrayList<>(result.size());
    resultObject.addAll(result);
    handleSetImportSelection(resultObject);
  }
コード例 #13
0
 private void editOrdered(Shell shell) {
   TableItem[] itemsIdMaps = fIdMapsTable.getSelection();
   TableItem[] itemsOrdered = fOrderedTable.getSelection();
   if (itemsOrdered.length > 0) {
     IdMap idmap = (IdMap) itemsIdMaps[0].getData();
     ArrayList idmapAL = (ArrayList) fOrderedElements.get(idmap.getName());
     Mapping mapping = (Mapping) itemsOrdered[0].getData();
     String idmapALKey = mapping.getKey();
     idmapAL.remove(idmapALKey);
     XMLCompareEditOrderedDialog dialog =
         new XMLCompareEditOrderedDialog(shell, mapping, null, true);
     if (dialog.open() == Window.OK) {
       idmapALKey = mapping.getKey();
       idmapAL.add(idmapALKey);
       fOrderedTable.remove(fOrderedTable.indexOf(itemsOrdered[0]));
       newOrderedTableItem(mapping, true);
     }
   }
 }
コード例 #14
0
 protected void selectionChanged() {
   TableItem[] items = fIdMapsTable.getSelection();
   if (items.length > 0) {
     // Refresh Mappings Table
     fMappingsTable.removeAll();
     Vector Mappings = ((IdMap) items[0].getData()).getMappings();
     for (Enumeration enumeration = Mappings.elements(); enumeration.hasMoreElements(); ) {
       newMappingsTableItem((Mapping) enumeration.nextElement(), false);
     }
     // Refresh Ordered Table
     fOrderedTable.removeAll();
     ArrayList Ordered = ((IdMap) items[0].getData()).getOrdered();
     if (Ordered != null) {
       for (Iterator iter_ordered = Ordered.iterator(); iter_ordered.hasNext(); ) {
         newOrderedTableItem((Mapping) iter_ordered.next(), false);
       }
     }
   }
   updateEnabledState();
 }
コード例 #15
0
 private void handleAddWorkingSet() {
   IWorkingSetManager manager = PlatformUI.getWorkbench().getWorkingSetManager();
   IWorkingSetSelectionDialog dialog =
       manager.createWorkingSetSelectionDialog(PDEPlugin.getActiveWorkbenchShell(), true);
   if (dialog.open() == Window.OK) {
     IWorkingSet[] workingSets = dialog.getSelection();
     IProduct product = getProduct();
     IProductModelFactory factory = product.getModel().getFactory();
     ArrayList<IProductPlugin> pluginList = new ArrayList<IProductPlugin>();
     for (int i = 0; i < workingSets.length; i++) {
       IAdaptable[] elements = workingSets[i].getElements();
       for (int j = 0; j < elements.length; j++) {
         IPluginModelBase model = findModel(elements[j]);
         if (model != null) {
           IProductPlugin plugin = factory.createPlugin();
           IPluginBase base = model.getPluginBase();
           plugin.setId(base.getId());
           pluginList.add(plugin);
         }
       }
     }
     product.addPlugins(pluginList.toArray(new IProductPlugin[pluginList.size()]));
   }
 }
コード例 #16
0
ファイル: SootLauncher.java プロジェクト: safdariqbal/soot
  private ArrayList convertPkgList(ArrayList pkgList) {
    ArrayList conList = new ArrayList();
    Iterator it = pkgList.iterator();
    while (it.hasNext()) {
      CallData cd = (CallData) it.next();
      TestNode tn = null;
      if (alreadyDone.containsKey(cd)) {
        tn = (TestNode) alreadyDone.get(cd);
      } else {
        tn = new TestNode();
        tn.setData(cd.getData());
        alreadyDone.put(cd, tn);
        if (cd.getChildren().size() != 0) {
          tn.setChildren(convertPkgList(cd.getChildren()));
        }
        if (cd.getOutputs().size() != 0) {
          tn.setOutputs(convertPkgList(cd.getOutputs()));
        }
      }
      conList.add(tn);
    }

    return conList;
  }
コード例 #17
0
  public static void handleAddRequired(IProductPlugin[] plugins, boolean includeOptional) {
    if (plugins.length == 0) return;

    ArrayList<BundleDescription> list = new ArrayList<BundleDescription>(plugins.length);
    for (int i = 0; i < plugins.length; i++) {
      list.add(TargetPlatformHelper.getState().getBundle(plugins[i].getId(), null));
    }
    DependencyCalculator calculator = new DependencyCalculator(includeOptional);
    calculator.findDependencies(list.toArray());

    BundleDescription[] bundles = TargetPlatformHelper.getState().getBundles();
    for (int i = 0; i < bundles.length; i++) {
      HostSpecification host = bundles[i].getHost();
      if (host != null
          && !("org.eclipse.ui.workbench.compatibility"
              .equals(bundles[i].getSymbolicName())) // $NON-NLS-1$
          && calculator.containsPluginId(host.getName())) {
        calculator.findDependency(bundles[i]);
      }
    }

    Collection<?> dependencies = calculator.getBundleIDs();

    IProduct product = plugins[0].getProduct();
    IProductModelFactory factory = product.getModel().getFactory();
    IProductPlugin[] requiredPlugins = new IProductPlugin[dependencies.size()];
    int i = 0;
    Iterator<?> iter = dependencies.iterator();
    while (iter.hasNext()) {
      String id = iter.next().toString();
      IProductPlugin plugin = factory.createPlugin();
      plugin.setId(id);
      requiredPlugins[i++] = plugin;
    }
    product.addPlugins(requiredPlugins);
  }
コード例 #18
0
 private void removeOrdered(Shell shell) {
   TableItem[] itemsIdMaps = fIdMapsTable.getSelection();
   TableItem[] itemsOrdered = fOrderedTable.getSelection();
   if (itemsOrdered.length > 0 && itemsIdMaps.length > 0) {
     Mapping mapping = (Mapping) itemsOrdered[0].getData();
     IdMap idmap = (IdMap) itemsIdMaps[0].getData();
     ArrayList idmapAL = (ArrayList) fOrderedElements.get(idmap.getName());
     idmapAL.remove(mapping.getKey());
     if (idmapAL.size() <= 0) fOrderedElements.remove(idmap.getName());
     ArrayList ordered = idmap.getOrdered();
     ordered.remove(mapping);
     if (ordered.size() <= 0) idmap.setOrdered(null);
     itemsOrdered[0].dispose(); // Table is single selection
   }
 }
コード例 #19
0
  private void editIdMap(Shell shell) {
    TableItem[] items = fIdMapsTable.getSelection();
    if (items.length > 0) {
      IdMap idmap = (IdMap) items[0].getData();
      XMLCompareEditCopyIdMapDialog dialog =
          new XMLCompareEditCopyIdMapDialog(shell, idmap, fIdMaps, fIdMapsInternal);
      if (dialog.open() == Window.OK) {
        String new_idmapName = dialog.getResult();
        if (!fIdMaps.containsKey(new_idmapName)) {
          // copy over id mappings
          Vector newMappings = new Vector();
          IdMap newIdMap = new IdMap(new_idmapName, false, newMappings);
          HashMap newIdmapHM = new HashMap();
          fIdMaps.put(newIdMap.getName(), newIdmapHM);
          Vector Mappings = idmap.getMappings();
          for (Enumeration enumeration = Mappings.elements(); enumeration.hasMoreElements(); ) {
            Mapping mapping = (Mapping) enumeration.nextElement();
            Mapping newMapping =
                new Mapping(mapping.getElement(), mapping.getSignature(), mapping.getIdAttribute());
            newMappings.add(newMapping);
            newIdmapHM.put(newMapping.getKey(), newMapping.getIdAttribute());
          }
          // copy over ordered entries
          ArrayList orderedAL = idmap.getOrdered();
          if (orderedAL != null && orderedAL.size() > 0) {
            ArrayList newOrderedAL = new ArrayList();
            newIdMap.setOrdered(newOrderedAL);
            ArrayList idmapOrdered = new ArrayList();
            fOrderedElements.put(newIdMap.getName(), idmapOrdered);
            for (Iterator iter = orderedAL.iterator(); iter.hasNext(); ) {
              Mapping ordered = (Mapping) iter.next();
              Mapping newOrdered = new Mapping(ordered.getElement(), ordered.getSignature());
              newOrderedAL.add(newOrdered);
              idmapOrdered.add(newOrdered.getKey());
            }
          }

          newIdMapsTableItem(newIdMap, true);
          selectionChanged();
        }
      }
    }
  }
コード例 #20
0
  private void handleSwap() {
    TableItem[] aItems = fAvailableListViewer.getTable().getItems();
    TableItem[] iItems = fImportListViewer.getTable().getItems();

    ArrayList<Object> data = new ArrayList<>();
    for (int i = 0; i < iItems.length; i++) {
      data.add(iItems[i].getData());
    }
    if (data.size() > 0) {
      doRemove(data);
    }

    data.clear();
    for (int i = 0; i < aItems.length; i++) {
      data.add(aItems[i].getData());
    }
    if (data.size() > 0) {
      doAdd(data);
    }
    pageChanged();
  }
コード例 #21
0
 private void addOrdered(Shell shell) {
   TableItem[] items = fIdMapsTable.getSelection();
   if (items.length > 0) {
     //			Set orderedSet= fOrderedElements.keySet();
     //			for (Iterator iter= orderedSet.iterator(); iter.hasNext(); ) {
     //				String IdMapName= (String) iter.next();
     //				ArrayList ordered= (ArrayList) fOrderedElements.get(IdMapName);
     //				for (Iterator iter2= ordered.iterator(); iter2.hasNext(); ) {
     //					System.out.println(IdMapName + ": " + iter2.next()); //$NON-NLS-1$
     //				}
     //			}
     IdMap idmap = (IdMap) items[0].getData();
     Mapping mapping = new Mapping();
     ArrayList idmapAL = (ArrayList) fOrderedElements.get(idmap.getName());
     if (idmapAL == null) idmapAL = new ArrayList();
     XMLCompareEditOrderedDialog dialog =
         new XMLCompareEditOrderedDialog(shell, mapping, idmapAL, false);
     if (dialog.open() == Window.OK) {
       String idmapALKey = mapping.getKey();
       if (!idmapAL.contains(idmapALKey)) {
         idmapAL.add(idmapALKey);
         newOrderedTableItem(mapping, true);
         ArrayList ordered = idmap.getOrdered();
         if (ordered == null) {
           ordered = new ArrayList();
           ordered.add(mapping);
           idmap.setOrdered(ordered);
         } else {
           ordered.add(mapping);
         }
         if (!fOrderedElements.containsKey(idmap.getName()))
           fOrderedElements.put(idmap.getName(), idmapAL);
       }
     }
   }
 }