lang-api/src/com/intellij/psi/search/scope/packageSet/NamedScopesHolder.java

   1 /*
   2  * Copyright 2000-2007 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.psi.search.scope.packageSet;
  17
  18 import com.intellij.openapi.components.PersistentStateComponent;
  19 import com.intellij.openapi.project.Project;
  20 import com.intellij.packageDependencies.DependencyValidationManager;
  21 import org.jdom.Element;
  22 import org.jetbrains.annotations.NonNls;
  23 import org.jetbrains.annotations.NotNull;
  24 import org.jetbrains.annotations.Nullable;
  25
  26 import javax.swing.*;
  27 import java.util.ArrayList;
  28 import java.util.Arrays;
  29 import java.util.Collections;
  30 import java.util.List;
  31
  32 public abstract class NamedScopesHolder implements PersistentStateComponent<Element> {
  33   private List<NamedScope> myScopes = new ArrayList<NamedScope>();
  34   @NonNls private static final String SCOPE_TAG = "scope";
  35   @NonNls private static final String NAME_ATT = "name";
  36   @NonNls private static final String PATTERN_ATT = "pattern";
  37
  38   public abstract String getDisplayName();
  39   public abstract Icon getIcon();
  40
  41   public static interface ScopeListener {
  42     void scopesChanged();
  43   }
  44   private List<ScopeListener> myScopeListeners;
  45   public synchronized void addScopeListener(ScopeListener scopeListener) {
  46     if (myScopeListeners == null) {
  47       myScopeListeners = new ArrayList<ScopeListener>();
  48     }
  49     myScopeListeners.add(scopeListener);
  50   }
  51   public synchronized void removeScopeListener(ScopeListener scopeListener) {
  52     myScopeListeners.remove(scopeListener);
  53   }
  54
  55   public synchronized void fireScopeListeners() {
  56     if (myScopeListeners != null) {
  57       for (ScopeListener listener : myScopeListeners) {
  58         listener.scopesChanged();
  59       }
  60     }
  61   }
  62
  63   @NotNull public NamedScope[] getScopes() {
  64     final List<NamedScope> scopes = new ArrayList<NamedScope>();
  65     List<NamedScope> list = getPredefinedScopes();
  66     scopes.addAll(list);
  67     scopes.addAll(myScopes);
  68     return scopes.toArray(new NamedScope[scopes.size()]);
  69   }
  70
  71   public NamedScope[] getEditableScopes(){
  72     return myScopes.toArray(new NamedScope[myScopes.size()]);
  73   }
  74
  75   public void removeAllSets() {
  76     myScopes.clear();
  77     fireScopeListeners();
  78   }
  79
  80   public void setScopes(NamedScope[] scopes) {
  81     myScopes = new ArrayList<NamedScope>(Arrays.asList(scopes));
  82     fireScopeListeners();
  83   }
  84
  85   public void addScope(NamedScope scope) {
  86     myScopes.add(scope);
  87     fireScopeListeners();
  88   }
  89
  90   @Nullable
  91   public static NamedScope getScope(final Project project, final String scopeName) {
  92     final NamedScopesHolder[] holders = getAllNamedScopeHolders(project);
  93     for (NamedScopesHolder holder : holders) {
  94       final NamedScope scope = holder.getScope(scopeName);
  95       if (scope != null) {
  96         return scope;
  97       }
  98     }
  99     return null;
 100   }
 101
 102   public static NamedScopesHolder[] getAllNamedScopeHolders(final Project project) {
 103     NamedScopesHolder[] holders = new NamedScopesHolder[2];
 104     holders [0] = NamedScopeManager.getInstance(project);
 105     holders [1] = DependencyValidationManager.getInstance(project);
 106     return holders;
 107   }
 108
 109   @Nullable
 110   public static NamedScopesHolder getHolder(final Project project, final String scopeName, final NamedScopesHolder defaultHolder) {
 111     final NamedScopesHolder[] holders = getAllNamedScopeHolders(project);
 112     for (NamedScopesHolder holder : holders) {
 113       final NamedScope scope = holder.getScope(scopeName);
 114       if (scope != null) {
 115         return holder;
 116       }
 117     }
 118     return defaultHolder;
 119   }
 120
 121   private static Element writeScope(NamedScope scope) {
 122     Element setElement = new Element(SCOPE_TAG);
 123     setElement.setAttribute(NAME_ATT, scope.getName());
 124     final PackageSet packageSet = scope.getValue();
 125     setElement.setAttribute(PATTERN_ATT, packageSet != null ? packageSet.getText() : "");
 126     return setElement;
 127   }
 128
 129   private static NamedScope readScope(Element setElement){
 130     String name = setElement.getAttributeValue(NAME_ATT);
 131     PackageSet set = null;
 132     try {
 133       set = PackageSetFactory.getInstance().compile(setElement.getAttributeValue(PATTERN_ATT));
 134     }
 135     catch (ParsingException e) {
 136       // Skip damaged set
 137     }
 138     return new NamedScope(name, set);
 139   }
 140
 141   public void loadState(final Element state) {
 142     List sets = state.getChildren(SCOPE_TAG);
 143     for (Object set : sets) {
 144       addScope(readScope((Element)set));
 145     }
 146     fireScopeListeners();
 147   }
 148
 149   public Element getState() {
 150     Element element = new Element("state");
 151     for (NamedScope myScope : myScopes) {
 152       element.addContent(writeScope(myScope));
 153     }
 154     return element;
 155   }
 156
 157   @Nullable
 158   public NamedScope getScope(@Nullable String name) {
 159     if (name == null) return null;
 160     for (NamedScope scope : myScopes) {
 161       if (name.equals(scope.getName())) return scope;
 162     }
 163     final List<NamedScope> predefinedScopes = getPredefinedScopes();
 164     for (NamedScope scope : predefinedScopes) {
 165       if (name.equals(scope.getName())) return scope;
 166     }
 167     return null;
 168   }
 169
 170   @NotNull
 171   public List<NamedScope> getPredefinedScopes(){
 172     return Collections.emptyList();
 173   }
 174 }