public void computeImports() throws CoreException {
// some existing imports may valid and can be preserved
Vector preservedImports = new Vector(fImports.size());
// new imports
ArrayList newImports = new ArrayList();
IPluginModelBase model = null;
for (int i = 0; i < fPlugins.size(); i++) {
IFeaturePlugin fp = (IFeaturePlugin) fPlugins.get(i);
ModelEntry entry = PluginRegistry.findEntry(fp.getId());
if (entry == null) continue;
IPluginModelBase[] models = entry.getActiveModels();
for (int j = 0; j < models.length; j++) {
IPluginModelBase m = models[j];
if (fp.getVersion().equals(m.getPluginBase().getVersion())
|| fp.getVersion().equals("0.0.0")) // $NON-NLS-1$
model = m;
}
if (model != null) {
addPluginImports(preservedImports, newImports, model.getPluginBase());
if (model.isFragmentModel()) {
BundleDescription desc = model.getBundleDescription();
if (desc == null) continue;
HostSpecification hostSpec = desc.getHost();
String id = hostSpec.getName();
String version = null;
int match = IMatchRules.NONE;
VersionRange versionRange = hostSpec.getVersionRange();
if (!(versionRange == null || VersionRange.emptyRange.equals(versionRange))) {
version =
versionRange.getMinimum() != null ? versionRange.getMinimum().toString() : null;
match = PluginBase.getMatchRule(versionRange);
}
addNewDependency(id, version, match, preservedImports, newImports);
}
}
}
// preserve imports of features
for (int i = 0; i < fImports.size(); i++) {
IFeatureImport iimport = (IFeatureImport) fImports.get(i);
if (iimport.getType() == IFeatureImport.FEATURE) preservedImports.add(iimport);
}
// removed = old - preserved
Vector removedImports = ((Vector) fImports.clone());
removedImports.removeAll(preservedImports);
// perform remove
fImports = preservedImports;
if (removedImports.size() > 0) {
fireStructureChanged(
(IFeatureImport[]) removedImports.toArray(new IFeatureImport[removedImports.size()]),
IModelChangedEvent.REMOVE);
}
// perform add
if (newImports.size() > 0) {
fImports.addAll(newImports);
fireStructureChanged(
(IFeatureImport[]) newImports.toArray(new IFeatureImport[newImports.size()]),
IModelChangedEvent.INSERT);
}
}
/**
* 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;
}
}
}
}
/**
* 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();
}
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();
}
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;
}