platform/lang-impl/src/com/intellij/internal/psiView/ViewerTreeStructure.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
  17 /**
  18  * class ViewerTreeStructure
  19  * created Aug 25, 2001
  20  * @author Jeka
  21  */
  22 package com.intellij.internal.psiView;
  23
  24 import com.intellij.ide.util.treeView.AbstractTreeStructure;
  25 import com.intellij.ide.util.treeView.NodeDescriptor;
  26 import com.intellij.lang.ASTNode;
  27 import com.intellij.openapi.application.ApplicationManager;
  28 import com.intellij.openapi.project.Project;
  29 import com.intellij.psi.PsiElement;
  30 import com.intellij.psi.PsiFile;
  31 import com.intellij.psi.PsiWhiteSpace;
  32 import com.intellij.psi.TokenType;
  33 import com.intellij.psi.impl.source.SourceTreeToPsiMap;
  34 import com.intellij.util.ArrayUtil;
  35 import org.jetbrains.annotations.NotNull;
  36
  37 import java.util.ArrayList;
  38 import java.util.List;
  39
  40 public class ViewerTreeStructure extends AbstractTreeStructure {
  41
  42   private boolean myShowWhiteSpaces = true;
  43   private boolean myShowTreeNodes = true;
  44
  45   private final Project myProject;
  46   private PsiElement myRootPsiElement = null;
  47   private final Object myRootElement = new Object();
  48
  49   public ViewerTreeStructure(Project project) {
  50     myProject = project;
  51   }
  52
  53   public void setRootPsiElement(PsiElement rootPsiElement) {
  54     myRootPsiElement = rootPsiElement;
  55   }
  56
  57   public PsiElement getRootPsiElement() {
  58     return myRootPsiElement;
  59   }
  60
  61   public Object getRootElement() {
  62     return myRootElement;
  63   }
  64
  65   public Object[] getChildElements(final Object element) {
  66     if (myRootElement == element) {
  67       if (myRootPsiElement == null) {
  68         return ArrayUtil.EMPTY_OBJECT_ARRAY;
  69       }
  70       return myRootPsiElement instanceof PsiFile ? ((PsiFile)myRootPsiElement).getPsiRoots() : new Object[]{myRootPsiElement};
  71     }
  72     final Object[][] children = new Object[1][];
  73     children[0] = ArrayUtil.EMPTY_OBJECT_ARRAY;
  74     ApplicationManager.getApplication().runReadAction(new Runnable() {
  75       public void run() {
  76         final Object[] result;
  77         if (myShowTreeNodes) {
  78           final ArrayList<Object> list = new ArrayList<Object>();
  79           final ASTNode root = element instanceof PsiElement? SourceTreeToPsiMap.psiElementToTree((PsiElement)element) :
  80                                element instanceof ASTNode? (ASTNode)element : null;
  81           if (root != null) {
  82             ASTNode child = root.getFirstChildNode();
  83             while (child != null) {
  84               if (myShowWhiteSpaces || child.getElementType() != TokenType.WHITE_SPACE) {
  85                 final PsiElement childElement = child.getPsi();
  86                 list.add(childElement == null ? child : childElement);
  87               }
  88               child = child.getTreeNext();
  89             }
  90           }
  91           result = ArrayUtil.toObjectArray(list);
  92         }
  93         else {
  94           final PsiElement[] elementChildren = ((PsiElement)element).getChildren();
  95           if (!myShowWhiteSpaces) {
  96             final List<PsiElement> childrenList = new ArrayList<PsiElement>(elementChildren.length);
  97             for (PsiElement psiElement : elementChildren) {
  98               if (!myShowWhiteSpaces && psiElement instanceof PsiWhiteSpace) {
  99                 continue;
 100               }
 101               childrenList.add(psiElement);
 102             }
 103             result = childrenList.toArray(new PsiElement[childrenList.size()]);
 104           }
 105           else {
 106             result = elementChildren;
 107           }
 108         }
 109         children[0] = result;
 110       }
 111     });
 112     return children[0];
 113   }
 114
 115   public Object getParentElement(Object element) {
 116     if (element == myRootElement) {
 117       return null;
 118     }
 119     if (element == myRootPsiElement) {
 120       return myRootElement;
 121     }
 122     return ((PsiElement)element).getParent();
 123   }
 124
 125   public void commit() {
 126   }
 127
 128   public boolean hasSomethingToCommit() {
 129     return false;
 130   }
 131
 132   @NotNull
 133   public NodeDescriptor createDescriptor(Object element, NodeDescriptor parentDescriptor) {
 134     if (element == myRootElement) {
 135       return new NodeDescriptor(myProject, null) {
 136         public boolean update() {
 137           return false;
 138         }
 139         public Object getElement() {
 140           return myRootElement;
 141         }
 142       };
 143     }
 144     return new ViewerNodeDescriptor(myProject, element, parentDescriptor);
 145   }
 146
 147   public boolean isShowWhiteSpaces() {
 148     return myShowWhiteSpaces;
 149   }
 150
 151   public void setShowWhiteSpaces(boolean showWhiteSpaces) {
 152     myShowWhiteSpaces = showWhiteSpaces;
 153   }
 154
 155   public boolean isShowTreeNodes() {
 156     return myShowTreeNodes;
 157   }
 158
 159   public void setShowTreeNodes(final boolean showTreeNodes) {
 160     myShowTreeNodes = showTreeNodes;
 161   }
 162 }