java/java-impl/src/com/intellij/util/text/ElementPresentation.java

   1 /*
   2  * Copyright 2000-2009 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.util.text;
  17
  18 import com.intellij.openapi.vfs.VirtualFile;
  19 import com.intellij.psi.*;
  20 import com.intellij.psi.util.PsiFormatUtil;
  21 import com.intellij.psi.util.PsiTreeUtil;
  22 import com.intellij.psi.xml.XmlTag;
  23
  24 public abstract class ElementPresentation {
  25   private final Noun myKind;
  26
  27   protected ElementPresentation(Noun kind) {
  28     myKind = kind;
  29   }
  30
  31   public static ElementPresentation forElement(PsiElement psiElement) {
  32     if (psiElement == null || !psiElement.isValid()) return new InvalidPresentation();
  33     if (psiElement instanceof PsiDirectory) return new ForDirectory((PsiDirectory)psiElement);
  34     if (psiElement instanceof PsiFile) return new ForFile((PsiFile)psiElement);
  35     if (psiElement instanceof PsiPackage) return new ForPackage((PsiPackage)psiElement);
  36     if (psiElement instanceof XmlTag) return new ForXmlTag((XmlTag)psiElement);
  37     if (psiElement instanceof PsiAnonymousClass) return new ForAnonymousClass((PsiAnonymousClass)psiElement);
  38     if (psiElement instanceof PsiClass) return new ForClass((PsiClass)psiElement);
  39     if (psiElement instanceof PsiMethod) return new ForMethod((PsiMethod)psiElement);
  40     if (psiElement instanceof PsiField) return new ForField((PsiField)psiElement);
  41     return new ForGeneralElement(psiElement);
  42   }
  43
  44   public static ElementPresentation forVirtualFile(VirtualFile file) {
  45     return new ForVirtualFile(file);
  46   }
  47
  48   private static boolean validNotNull(VirtualFile virtualFile) {
  49     return virtualFile != null && virtualFile.isValid();
  50   }
  51
  52   public abstract String getQualifiedName();
  53
  54   public Noun getKind() {
  55     return myKind;
  56   }
  57
  58   public abstract String getName();
  59
  60   public abstract String getComment();
  61
  62   public String getNameWithFQComment() {
  63     String comment = getComment();
  64     String result = getName();
  65     if (comment.trim().length() == 0) return result;
  66     return result + " (" + comment + ")";
  67   }
  68
  69   public static class Noun {
  70     private final int myTypeNum;
  71
  72     public static final Noun DIRECTORY = new Noun(0);
  73     public static final Noun PACKAGE = new Noun(1);
  74     public static final Noun FILE = new Noun(2);
  75     public static final Noun CLASS = new Noun(3);
  76     public static final Noun METHOD = new Noun(4);
  77     public static final Noun FIELD = new Noun(5);
  78     public static final Noun FRAGMENT = new Noun(6);
  79     public static final Noun XML_TAG = new Noun(7);
  80
  81     public Noun(int typeNum) {
  82       myTypeNum = typeNum;
  83     }
  84
  85     public int getTypeNum() {
  86       return myTypeNum;
  87     }
  88   }
  89
  90   private static class InvalidPresentation extends ElementPresentation {
  91     public InvalidPresentation() {
  92       super(new Noun(-1));
  93     }
  94
  95     public String getComment() {
  96       return "";
  97     }
  98
  99     public String getName() {
 100       return "INVALID";
 101     }
 102
 103     public String getQualifiedName() {
 104       return getName();
 105     }
 106   }
 107
 108   private static class ForDirectory extends ElementPresentation {
 109     private final PsiDirectory myPsiDirectory;
 110
 111     public ForDirectory(PsiDirectory psiDirectory) {
 112       super(Noun.DIRECTORY);
 113       myPsiDirectory = psiDirectory;
 114     }
 115
 116     public String getQualifiedName() {
 117       VirtualFile virtualFile = myPsiDirectory.getVirtualFile();
 118       if (validNotNull(virtualFile)) return virtualFile.getPresentableUrl();
 119       return myPsiDirectory.getName();
 120     }
 121
 122     public String getName() {
 123       return myPsiDirectory.getName();
 124     }
 125
 126     public String getComment() {
 127       PsiDirectory parentDirectory = myPsiDirectory.getParentDirectory();
 128       if (parentDirectory == null) return "";
 129       return ElementPresentation.forElement(parentDirectory).getQualifiedName();
 130     }
 131   }
 132
 133   private static class ForFile extends ElementPresentation {
 134     private final PsiFile myFile;
 135
 136     public ForFile(PsiFile file) {
 137       super(Noun.FILE);
 138       myFile = file;
 139     }
 140
 141     public String getQualifiedName() {
 142       VirtualFile virtualFile = myFile.getVirtualFile();
 143       if (validNotNull(virtualFile)) return virtualFile.getPresentableUrl();
 144       return myFile.getName();
 145     }
 146
 147     public String getName() {
 148       return myFile.getName();
 149     }
 150
 151     public String getComment() {
 152       PsiDirectory directory = myFile.getContainingDirectory();
 153       if (directory == null) return "";
 154       return ElementPresentation.forElement(directory).getQualifiedName();
 155     }
 156   }
 157
 158   public static class ForPackage extends ElementPresentation {
 159     private final PsiPackage myPsiPackage;
 160
 161     public ForPackage(PsiPackage psiPackage) {
 162       super(Noun.PACKAGE);
 163       myPsiPackage = psiPackage;
 164     }
 165
 166     public String getQualifiedName() {
 167       String qualifiedName = myPsiPackage.getQualifiedName();
 168       if (qualifiedName.length() == 0) return PsiBundle.message("default.package.presentation");
 169       return qualifiedName;
 170     }
 171
 172     public String getName() {
 173       return getQualifiedName();
 174     }
 175
 176     public String getComment() {
 177       return "";
 178     }
 179   }
 180
 181   private static class ForAnonymousClass extends ElementPresentation {
 182     private final PsiAnonymousClass myPsiAnonymousClass;
 183
 184     public ForAnonymousClass(PsiAnonymousClass psiAnonymousClass) {
 185       super(Noun.FRAGMENT);
 186       myPsiAnonymousClass = psiAnonymousClass;
 187     }
 188
 189     public String getQualifiedName() {
 190       PsiClass psiClass = PsiTreeUtil.getParentOfType(myPsiAnonymousClass, PsiClass.class);
 191       if (psiClass != null) return PsiBundle.message("anonymous.class.context.display", forElement(psiClass).getQualifiedName());
 192       return PsiBundle.message("anonymous.class.display");
 193     }
 194
 195     public String getName() {
 196       return getQualifiedName();
 197     }
 198
 199     public String getComment() {
 200       return "";
 201     }
 202   }
 203
 204   private static class ForClass extends ElementPresentation {
 205     private final PsiClass myPsiClass;
 206
 207     public ForClass(PsiClass psiClass) {
 208       super(Noun.CLASS);
 209       myPsiClass = psiClass;
 210     }
 211
 212     public String getQualifiedName() {
 213       return myPsiClass.getQualifiedName();
 214     }
 215
 216     public String getName() {
 217       return myPsiClass.getName();
 218     }
 219
 220     public String getComment() {
 221       PsiPackage psiPackage = JavaDirectoryService.getInstance().getPackage(myPsiClass.getContainingFile().getContainingDirectory());
 222       if (psiPackage == null) return "";
 223       return forElement(psiPackage).getQualifiedName();
 224     }
 225   }
 226
 227   private static class ForMethod extends ElementPresentation {
 228     private static final int FQ_OPTIONS = PsiFormatUtil.SHOW_CONTAINING_CLASS | PsiFormatUtil.SHOW_FQ_NAME | PsiFormatUtil.SHOW_NAME |
 229                                           PsiFormatUtil.SHOW_PARAMETERS;
 230     private static final int NAME_OPTIONS = PsiFormatUtil.SHOW_CONTAINING_CLASS | PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_PARAMETERS;
 231     private final PsiMethod myPsiMethod;
 232
 233     public ForMethod(PsiMethod psiMethod) {
 234       super(Noun.METHOD);
 235       myPsiMethod = psiMethod;
 236     }
 237
 238     public String getQualifiedName() {
 239       return PsiFormatUtil.formatMethod(myPsiMethod, PsiSubstitutor.EMPTY, FQ_OPTIONS, PsiFormatUtil.SHOW_TYPE);
 240     }
 241
 242     public String getName() {
 243       return PsiFormatUtil.formatMethod(myPsiMethod, PsiSubstitutor.EMPTY, NAME_OPTIONS, PsiFormatUtil.SHOW_TYPE);
 244     }
 245
 246     public String getComment() {
 247       PsiClass containingClass = myPsiMethod.getContainingClass();
 248       if (containingClass == null) return "";
 249       return forElement(containingClass).getComment();
 250     }
 251   }
 252
 253   private static class ForField extends ElementPresentation {
 254     private final PsiField myPsiField;
 255
 256     public ForField(PsiField psiField) {
 257       super(Noun.FIELD);
 258       myPsiField = psiField;
 259     }
 260
 261     public String getQualifiedName() {
 262       PsiClass psiClass = myPsiField.getContainingClass();
 263       String name = myPsiField.getName();
 264       if (psiClass != null) return forElement(psiClass).getQualifiedName() + "." + name;
 265       else return name;
 266     }
 267
 268     public String getName() {
 269       PsiClass psiClass = myPsiField.getContainingClass();
 270       String name = myPsiField.getName();
 271       if (psiClass == null) return name;
 272       return forElement(psiClass).getName() + "." + name;
 273     }
 274
 275     public String getComment() {
 276       PsiClass psiClass = myPsiField.getContainingClass();
 277       if (psiClass == null) return "";
 278       return forElement(psiClass).getComment();
 279     }
 280   }
 281
 282   private static class ForGeneralElement extends ElementPresentation {
 283     private final PsiElement myPsiElement;
 284
 285     public ForGeneralElement(PsiElement psiElement) {
 286       super(Noun.FRAGMENT);
 287       myPsiElement = psiElement;
 288     }
 289
 290     public String getQualifiedName() {
 291       PsiFile containingFile = myPsiElement.getContainingFile();
 292       if (containingFile != null) return PsiBundle.message("code.from.context.display", forElement(containingFile).getQualifiedName());
 293       return PsiBundle.message("code.display");
 294     }
 295
 296     public String getName() {
 297       return getQualifiedName();
 298     }
 299
 300     public String getComment() {
 301       return "";
 302     }
 303   }
 304
 305   private static class ForXmlTag extends ElementPresentation {
 306     private final XmlTag myXmlTag;
 307
 308     public ForXmlTag(XmlTag xmlTag) {
 309       super(Noun.XML_TAG);
 310       myXmlTag = xmlTag;
 311     }
 312
 313     public String getQualifiedName() {
 314       return "<" + myXmlTag.getLocalName() + ">";
 315     }
 316
 317     public String getName() {
 318       return getQualifiedName();
 319     }
 320
 321     public String getComment() {
 322       return "";
 323     }
 324   }
 325
 326   private static class ForVirtualFile extends ElementPresentation {
 327     private final VirtualFile myFile;
 328
 329     public ForVirtualFile(VirtualFile file) {
 330       super(file.isDirectory() ? Noun.DIRECTORY : Noun.FILE);
 331       myFile = file;
 332     }
 333
 334     public String getComment() {
 335       String name = myFile.getName();
 336       if (!myFile.isValid()) return name;
 337       VirtualFile parent = myFile.getParent();
 338       if (parent == null) return name;
 339       return parent.getPresentableUrl();
 340     }
 341
 342     public String getName() {
 343       return myFile.getName();
 344     }
 345
 346     public String getQualifiedName() {
 347       if (!myFile.isValid()) return myFile.getName();
 348       return myFile.getPresentableUrl();
 349     }
 350   }
 351 }