platform/lang-impl/src/com/intellij/ide/todo/TodoConfiguration.java

   1 package com.intellij.ide.todo;
   2
   3 import com.intellij.ExtensionPoints;
   4 import com.intellij.openapi.application.ApplicationManager;
   5 import com.intellij.openapi.components.ApplicationComponent;
   6 import com.intellij.openapi.extensions.Extensions;
   7 import com.intellij.openapi.util.InvalidDataException;
   8 import com.intellij.openapi.util.JDOMExternalizable;
   9 import com.intellij.openapi.util.WriteExternalException;
  10 import com.intellij.psi.search.IndexPattern;
  11 import com.intellij.psi.search.IndexPatternProvider;
  12 import com.intellij.psi.search.TodoAttributes;
  13 import com.intellij.psi.search.TodoPattern;
  14 import com.intellij.util.EventDispatcher;
  15 import org.jdom.Element;
  16 import org.jetbrains.annotations.NonNls;
  17 import org.jetbrains.annotations.NotNull;
  18
  19 import java.beans.PropertyChangeEvent;
  20 import java.beans.PropertyChangeListener;
  21 import java.util.ArrayList;
  22 import java.util.Iterator;
  23
  24 /**
  25  * @author Vladimir Kondratyev
  26  */
  27 public class TodoConfiguration implements ApplicationComponent, JDOMExternalizable, IndexPatternProvider {
  28   private TodoPattern[] myTodoPatterns;
  29   private TodoFilter[] myTodoFilters;
  30   private IndexPattern[] myIndexPatterns;
  31
  32   private final EventDispatcher<PropertyChangeListener> myPropertyChangeMulticaster = EventDispatcher.create(PropertyChangeListener.class);
  33
  34   @NonNls public static final String PROP_TODO_PATTERNS = "todoPatterns";
  35   @NonNls public static final String PROP_TODO_FILTERS = "todoFilters";
  36   @NonNls private static final String ELEMENT_PATTERN = "pattern";
  37   @NonNls private static final String ELEMENT_FILTER = "filter";
  38
  39   /**
  40    * Invoked by reflection
  41    */
  42   TodoConfiguration() {
  43     Extensions.getRootArea().getExtensionPoint(ExtensionPoints.INDEX_PATTERN_PROVIDER).registerExtension(this);
  44     resetToDefaultTodoPatterns();
  45   }
  46
  47   public void resetToDefaultTodoPatterns() {
  48     myTodoPatterns = new TodoPattern[]{
  49       new TodoPattern("\\btodo\\b.*", TodoAttributes.createDefault(), false)
  50     };
  51     myTodoFilters = new TodoFilter[]{};
  52     buildIndexPatterns();
  53   }
  54
  55   private void buildIndexPatterns() {
  56     myIndexPatterns = new IndexPattern[myTodoPatterns.length];
  57     for(int i=0; i<myTodoPatterns.length; i++) {
  58       myIndexPatterns [i] = myTodoPatterns [i].getIndexPattern();
  59     }
  60   }
  61
  62   public static TodoConfiguration getInstance() {
  63     return ApplicationManager.getApplication().getComponent(TodoConfiguration.class);
  64   }
  65
  66   public String getComponentName() {
  67     return "TodoConfiguration";
  68   }
  69
  70   public void initComponent() { }
  71
  72   public void disposeComponent() {
  73   }
  74
  75   public TodoPattern[] getTodoPatterns() {
  76     return myTodoPatterns;
  77   }
  78
  79   @NotNull public IndexPattern[] getIndexPatterns() {
  80     return myIndexPatterns;
  81   }
  82
  83   public void setTodoPatterns(TodoPattern[] patterns) {
  84     TodoPattern[] oldPatterns = myTodoPatterns;
  85     myTodoPatterns = patterns;
  86     buildIndexPatterns();
  87     myPropertyChangeMulticaster.getMulticaster().propertyChange(new PropertyChangeEvent(this, PROP_INDEX_PATTERNS, oldPatterns, patterns));
  88     myPropertyChangeMulticaster.getMulticaster().propertyChange(new PropertyChangeEvent(this, PROP_TODO_PATTERNS, oldPatterns, patterns));
  89   }
  90
  91   /**
  92    * @return <code>TodoFilter</code> with specified <code>name</code>. Method returns
  93    *         <code>null</code> if there is no filter with <code>name</code>.
  94    */
  95   public TodoFilter getTodoFilter(String name) {
  96     for (int i = 0; i < myTodoFilters.length; i++) {
  97       TodoFilter filter = myTodoFilters[i];
  98       if (filter.getName().equals(name)) {
  99         return filter;
 100       }
 101     }
 102     return null;
 103   }
 104
 105   /**
 106    * @return all <code>TodoFilter</code>s.
 107    */
 108   public TodoFilter[] getTodoFilters() {
 109     return myTodoFilters;
 110   }
 111
 112   public void setTodoFilters(TodoFilter[] filters) {
 113     TodoFilter[] oldFilters = myTodoFilters;
 114     myTodoFilters = filters;
 115     myPropertyChangeMulticaster.getMulticaster().propertyChange(new PropertyChangeEvent(this, PROP_TODO_FILTERS, oldFilters, filters));
 116   }
 117
 118   public void addPropertyChangeListener(PropertyChangeListener listener) {
 119     myPropertyChangeMulticaster.addListener(listener);
 120   }
 121
 122   public void removePropertyChangeListener(PropertyChangeListener listener) {
 123     myPropertyChangeMulticaster.removeListener(listener);
 124   }
 125
 126   public void readExternal(Element element) throws InvalidDataException {
 127     ArrayList<TodoPattern> patternsList = new ArrayList<TodoPattern>();
 128     ArrayList<TodoFilter> filtersList = new ArrayList<TodoFilter>();
 129     for (Iterator i = element.getChildren().iterator(); i.hasNext();) {
 130       Element child = (Element)i.next();
 131       if (ELEMENT_PATTERN.equals(child.getName())) {
 132         TodoPattern pattern = new TodoPattern();
 133         pattern.readExternal(child);
 134         patternsList.add(pattern);
 135       }
 136       else if (ELEMENT_FILTER.equals(child.getName())) {
 137         TodoPattern[] patterns = patternsList.toArray(new TodoPattern[patternsList.size()]);
 138         TodoFilter filter = new TodoFilter();
 139         filter.readExternal(child, patterns);
 140         filtersList.add(filter);
 141       }
 142     }
 143     setTodoPatterns(patternsList.toArray(new TodoPattern[patternsList.size()]));
 144     setTodoFilters(filtersList.toArray(new TodoFilter[filtersList.size()]));
 145   }
 146
 147   public void writeExternal(Element element) throws WriteExternalException {
 148     for (int i = 0; i < myTodoPatterns.length; i++) {
 149       TodoPattern pattern = myTodoPatterns[i];
 150       Element child = new Element(ELEMENT_PATTERN);
 151       pattern.writeExternal(child);
 152       element.addContent(child);
 153     }
 154     for (int i = 0; i < myTodoFilters.length; i++) {
 155       TodoFilter filter = myTodoFilters[i];
 156       Element child = new Element(ELEMENT_FILTER);
 157       filter.writeExternal(child, myTodoPatterns);
 158       element.addContent(child);
 159     }
 160   }
 161 }