lang-impl/src/com/intellij/codeInsight/lookup/LookupItem.java

   1 package com.intellij.codeInsight.lookup;
   2
   3 import com.intellij.codeInsight.TailType;
   4 import com.intellij.codeInsight.completion.CompletionUtil;
   5 import com.intellij.codeInsight.completion.InsertHandler;
   6 import com.intellij.codeInsight.completion.InsertionContext;
   7 import com.intellij.codeInsight.lookup.impl.ElementLookupRenderer;
   8 import com.intellij.codeInsight.lookup.impl.LookupElementPresentationEx;
   9 import com.intellij.openapi.editor.Editor;
  10 import com.intellij.openapi.extensions.Extensions;
  11 import com.intellij.openapi.util.Comparing;
  12 import com.intellij.openapi.util.Key;
  13 import com.intellij.util.containers.HashMap;
  14 import gnu.trove.THashSet;
  15 import org.jetbrains.annotations.NonNls;
  16 import org.jetbrains.annotations.NotNull;
  17 import org.jetbrains.annotations.Nullable;
  18
  19 import javax.swing.*;
  20 import java.util.Arrays;
  21 import java.util.Map;
  22 import java.util.Set;
  23
  24 /**
  25  * This class represents an item of a lookup list.
  26  */
  27 public class LookupItem<T> extends MutableLookupElement<T> implements Comparable {
  28   public static final Object HIGHLIGHTED_ATTR = Key.create("highlighted");
  29   public static final Object TYPE_ATTR = Key.create("type");
  30   public static final Object ICON_ATTR = Key.create("icon");
  31   public static final Object TYPE_TEXT_ATTR = Key.create("typeText");
  32   public static final Object TAIL_TEXT_ATTR = Key.create("tailText");
  33   public static final Object TAIL_TEXT_SMALL_ATTR = Key.create("tailTextSmall");
  34   public static final Key<Object> FORCE_SHOW_SIGNATURE_ATTR = Key.create("forceShowSignature");
  35
  36   public static final Object DO_AUTOCOMPLETE_ATTR = Key.create("DO_AUTOCOMPLETE_ATTR");
  37
  38   public static final Object GENERATE_ANONYMOUS_BODY_ATTR = Key.create("GENERATE_ANONYMOUS_BODY_ATTR");
  39   public static final Key<Object> BRACKETS_COUNT_ATTR = Key.create("BRACKETS_COUNT_ATTR");
  40   public static final Key<Object> OVERWRITE_ON_AUTOCOMPLETE_ATTR = Key.create("OVERWRITE_ON_AUTOCOMPLETE_ATTR");
  41   public static final Object NEW_OBJECT_ATTR = Key.create("NEW_OBJECT_ATTR");
  42   public static final Object DONT_CHECK_FOR_INNERS = Key.create("DONT_CHECK_FOR_INNERS");
  43   public static final Object FORCE_QUALIFY = Key.create("FORCE_QUALIFY");
  44   public static final Object SUBSTITUTOR = Key.create("SUBSTITUTOR");
  45   public static final Object TYPE = Key.create("TYPE");
  46   public static final Object INDICATE_ANONYMOUS = Key.create("INDICATE ANONYMOUS");
  47   public static final Key<Object> DEPRECATED_ATTR = Key.create("DEPRECATED");
  48
  49   public static final Key<Comparable[]> WEIGHT = Key.create("WEIGHT");
  50
  51   public static final Object CASE_INSENSITIVE = Key.create("CASE_INSENSITIVE");
  52
  53   public static final Key<TailType> TAIL_TYPE_ATTR = Key.create("myTailType"); // one of constants defined in SimpleTailType interface
  54
  55   private Object myObject;
  56   private String myLookupString;
  57   private InsertHandler myInsertHandler;
  58   private double myPriority;
  59   private int myGrouping;
  60   private Map<Object,Object> myAttributes = null;
  61   public static final LookupItem[] EMPTY_ARRAY = new LookupItem[0];
  62   private final Set<String> myAllLookupStrings = new THashSet<String>();
  63   private String myPresentable;
  64   private AutoCompletionPolicy myAutoCompletionPolicy = AutoCompletionPolicy.SETTINGS_DEPENDENT;
  65
  66   public LookupItem(T o, @NotNull @NonNls String lookupString){
  67     setObject(o);
  68     setLookupString(lookupString);
  69   }
  70
  71   public static LookupItem fromString(String s) {
  72     return new LookupItem<String>(s, s);
  73   }
  74
  75   public void setObject(@NotNull T o) {
  76     myObject = o;
  77
  78     if (o instanceof LookupValueWithPriority) {
  79       setPriority(((LookupValueWithPriority)o).getPriority());
  80     }
  81   }
  82
  83   public boolean equals(Object o){
  84     if (o == this) return true;
  85     if (o instanceof LookupItem){
  86       LookupItem item = (LookupItem)o;
  87       return Comparing.equal(myObject, item.myObject)
  88              && Comparing.equal(myLookupString, item.myLookupString)
  89              && Comparing.equal(myAllLookupStrings, item.myAllLookupStrings)
  90              && Comparing.equal(myAttributes, item.myAttributes);
  91     }
  92     return false;
  93   }
  94
  95   public int hashCode() {
  96     return myAllLookupStrings.hashCode() * 239 + getObject().hashCode();
  97   }
  98
  99   public String toString() {
 100     return getLookupString();
 101   }
 102
 103   /**
 104    * Returns a data object.  This object is used e.g. for rendering the node.
 105    */
 106   @NotNull
 107   public T getObject() {
 108     return (T)myObject;
 109   }
 110
 111   /**
 112    * Returns a string which will be inserted to the editor when this item is
 113    * choosen.
 114    */
 115   @NotNull
 116   public String getLookupString() {
 117     return myLookupString;
 118   }
 119
 120   public void setLookupString(@NotNull String lookupString) {
 121     if (myAllLookupStrings.contains("")) myAllLookupStrings.remove("");
 122     myLookupString = lookupString;
 123     myAllLookupStrings.add(lookupString);
 124   }
 125
 126   public Object getAttribute(Object key){
 127     if (myAttributes != null){
 128       return myAttributes.get(key);
 129     }
 130     else{
 131       return null;
 132     }
 133   }
 134
 135   public <T> T getAttribute(Key<T> key) {
 136     if (myAttributes != null){
 137       //noinspection unchecked
 138       return (T)myAttributes.get(key);
 139     }
 140     else{
 141       return null;
 142     }
 143   }
 144
 145   public void setAttribute(Object key, Object value){
 146     if (myAttributes == null){
 147       myAttributes = new HashMap<Object, Object>(5);
 148     }
 149     myAttributes.put(key, value);
 150   }
 151
 152   public <T> void setAttribute(Key<T> key, T value){
 153     if (value == null && myAttributes != null) {
 154       myAttributes.remove(key);
 155       return;
 156     }
 157
 158     if (myAttributes == null){
 159       myAttributes = new HashMap<Object, Object>(5);
 160     }
 161     myAttributes.put(key, value);
 162   }
 163
 164   public InsertHandler<? extends LookupItem> getInsertHandler(){
 165     return myInsertHandler;
 166   }
 167
 168   public boolean isBold() {
 169     return getAttribute(HIGHLIGHTED_ATTR) != null;
 170   }
 171
 172   @Override
 173   public void handleInsert(final InsertionContext context) {
 174     super.handleInsert(context);
 175     if (getTailType() != TailType.UNKNOWN && myInsertHandler == null) {
 176       context.setAddCompletionChar(false);
 177       final TailType type = handleCompletionChar(context.getEditor(), this, context.getCompletionChar());
 178       type.processTail(context.getEditor(), context.getTailOffset());
 179     }
 180   }
 181
 182   @Nullable
 183   public static TailType getDefaultTailType(final char completionChar) {
 184     switch(completionChar){
 185       case '.': return TailType.DOT;
 186       case ',': return TailType.COMMA;
 187       case ';': return TailType.SEMICOLON;
 188       case '=': return TailType.EQ;
 189       case ' ': return TailType.SPACE;
 190       case ':': return TailType.CASE_COLON; //?
 191       case Lookup.COMPLETE_STATEMENT_SELECT_CHAR: return TailType.SMART_COMPLETION;
 192     }
 193     return null;
 194   }
 195
 196   @NotNull
 197   public static TailType handleCompletionChar(@NotNull final Editor editor, @NotNull final LookupElement lookupElement, final char completionChar) {
 198     final TailType type = getDefaultTailType(completionChar);
 199     if (type != null) {
 200       return type;
 201     }
 202
 203     final LookupItem<?> item = (LookupItem)lookupElement;
 204     final TailType attr = item.getAttribute(CompletionUtil.TAIL_TYPE_ATTR);
 205     return attr != null ? attr : TailType.NONE;
 206   }
 207
 208
 209   @NotNull
 210   public TailType getTailType(){
 211     final TailType tailType = getAttribute(TAIL_TYPE_ATTR);
 212     return tailType != null ? tailType : TailType.UNKNOWN;
 213   }
 214
 215   @NotNull
 216   public LookupItem<T> setTailType(@NotNull TailType type) {
 217     setAttribute(TAIL_TYPE_ATTR, type);
 218     return this;
 219   }
 220
 221   public int compareTo(Object o){
 222     if(o instanceof String){
 223       return getLookupString().compareTo((String)o);
 224     }
 225     if(!(o instanceof LookupItem)){
 226       throw new RuntimeException("Trying to compare LookupItem with " + o.getClass() + "!!!");
 227     }
 228     return getLookupString().compareTo(((LookupItem)o).getLookupString());
 229   }
 230
 231   public LookupItem<T> setInsertHandler(@NotNull final InsertHandler<? extends LookupElement> handler) {
 232     myInsertHandler = handler;
 233     return this;
 234   }
 235
 236   @NotNull
 237   protected LookupElementRenderer<? extends LookupItem> getRenderer() {
 238     for (final ElementLookupRenderer renderer : Extensions.getExtensions(ElementLookupRenderer.EP_NAME)) {
 239       if (renderer.handlesItem(getObject())) return new LookupElementRenderer<LookupItem>() {
 240         public void renderElement(final LookupItem element, final LookupElementPresentation presentation) {
 241           renderer.renderElement(element, element.getObject(), (LookupElementPresentationEx)presentation);
 242         }
 243       };
 244     }
 245     return DefaultLookupItemRenderer.INSTANCE;
 246   }
 247
 248   public LookupItem<T> setBold() {
 249     setAttribute(HIGHLIGHTED_ATTR, "");
 250     return this;
 251   }
 252
 253   public LookupItem<T> setDeprecated(boolean deprecated) {
 254     setAttribute(DEPRECATED_ATTR, deprecated ? "" : null);
 255     return this;
 256   }
 257
 258   public LookupItem<T> setAutoCompletionPolicy(final AutoCompletionPolicy policy) {
 259     myAutoCompletionPolicy = policy;
 260     return this;
 261   }
 262
 263   public AutoCompletionPolicy getAutoCompletionPolicy() {
 264     return myAutoCompletionPolicy;
 265   }
 266
 267   @NotNull
 268   public LookupItem<T> setIcon(Icon icon) {
 269     setAttribute(ICON_ATTR, icon);
 270     return this;
 271   }
 272
 273   @NotNull
 274   public LookupItem<T> setPriority(double priority) {
 275     myPriority = priority;
 276     return this;
 277   }
 278
 279   @NotNull
 280   public LookupItem<T> setGrouping(final int grouping) {
 281     myGrouping = grouping;
 282     return this;
 283   }
 284
 285   public final double getPriority() {
 286     return myPriority;
 287   }
 288
 289   @Override
 290   public final int getGrouping() {
 291     return myGrouping;
 292   }
 293
 294   @NotNull
 295   public LookupItem<T> setPresentableText(@NotNull final String displayText) {
 296     myPresentable = displayText;
 297     return this;
 298   }
 299
 300   @Nullable
 301   public String getPresentableText() {
 302     return myPresentable;
 303   }
 304
 305   @NotNull
 306   public LookupItem<T> setTypeText(final String text) {
 307     setAttribute(TYPE_TEXT_ATTR, text);
 308     return this;
 309   }
 310
 311   @NotNull
 312   @Override
 313   public MutableLookupElement<T> setTailText(final String text, final boolean grayed) {
 314     setAttribute(TAIL_TEXT_ATTR, text);
 315     setAttribute(TAIL_TEXT_SMALL_ATTR, Boolean.TRUE);
 316     return this;
 317   }
 318
 319   @NotNull
 320   public LookupItem<T> setCaseSensitive(final boolean caseSensitive) {
 321     setAttribute(CASE_INSENSITIVE, !caseSensitive);
 322     return this;
 323   }
 324
 325   public LookupItem<T> addLookupStrings(@NonNls final String... additionalLookupStrings) {
 326     myAllLookupStrings.addAll(Arrays.asList(additionalLookupStrings));
 327     return this;
 328   }
 329
 330   public Set<String> getAllLookupStrings() {
 331     return myAllLookupStrings;
 332   }
 333
 334   public void copyAttributes(final LookupItem item) {
 335     if (myAttributes == null) {
 336       if (item.myAttributes == null) return;
 337       myAttributes = new HashMap<Object, Object>(5);
 338     }
 339     myAttributes.putAll(item.myAttributes);
 340   }
 341
 342 }