source/com/intellij/util/xml/tree/DomModelTreeView.java

   1 package com.intellij.util.xml.tree;
   2
   3 import com.intellij.openapi.actionSystem.*;
   4 import com.intellij.openapi.actionSystem.ex.ActionManagerEx;
   5 import com.intellij.openapi.util.IconLoader;
   6 import com.intellij.ui.components.panels.Wrapper;
   7 import com.intellij.util.ui.tree.TreeUtil;
   8 import com.intellij.util.xml.DomElement;
   9 import com.intellij.util.xml.DomEventListener;
  10 import com.intellij.util.xml.DomManager;
  11 import com.intellij.util.xml.events.*;
  12 import jetbrains.fabrique.ui.treeStructure.*;
  13 import jetbrains.fabrique.ui.treeStructure.actions.CollapseAllAction;
  14 import jetbrains.fabrique.ui.treeStructure.actions.ExpandAllAction;
  15
  16 import javax.swing.*;
  17 import javax.swing.event.TreeExpansionListener;
  18 import javax.swing.event.TreeExpansionEvent;
  19 import javax.swing.tree.DefaultMutableTreeNode;
  20 import javax.swing.tree.DefaultTreeModel;
  21 import java.awt.*;
  22 import java.util.Map;
  23 import java.util.ArrayList;
  24
  25 import org.jetbrains.annotations.Nullable;
  26
  27 public class DomModelTreeView extends Wrapper implements DataProvider {
  28   public static String DOM_MODEL_TREE_VIEW_KEY = "DOM_MODEL_TREE_VIEW_KEY";
  29   public static String DOM_MODEL_TREE_VIEW_POPUP = "DOM_MODEL_TREE_VIEW_POPUP";
  30
  31   private final SimpleTree myTree;
  32   private final SimpleTreeBuilder myBuilder;
  33   private DomManager myDomManager;
  34   private DomEventListener myDomEventListener;
  35   private DomElement myRootElement;
  36
  37   public DomModelTreeView(DomElement rootElement) {
  38     this(rootElement, false);
  39   }
  40
  41   public DomModelTreeView(DomElement rootElement, boolean isRootVisible) {
  42     myRootElement = rootElement;
  43     myTree = new SimpleTree(new DefaultTreeModel(new DefaultMutableTreeNode()));
  44     myTree.setRootVisible(isRootVisible);
  45     myTree.setShowsRootHandles(true);
  46
  47     ToolTipManager.sharedInstance().registerComponent(myTree);
  48     TreeUtil.installActions(myTree);
  49
  50     final SimpleTreeStructure treeStructure = rootElement != null ? getTreeStructure(rootElement) : new SimpleTreeStructure() {
  51       public Object getRootElement() {
  52         return null;
  53       }
  54     };
  55
  56     myBuilder = new SimpleTreeBuilder(myTree, (DefaultTreeModel)myTree.getModel(), treeStructure, WeightBasedComparator.INSTANCE);
  57     myBuilder.setNodeDescriptorComparator(null);
  58     myBuilder.initRoot();
  59
  60     add(myTree, BorderLayout.CENTER);
  61
  62     myTree.addTreeExpansionListener(new TreeExpansionListener() {
  63       public void treeExpanded(TreeExpansionEvent event) {
  64         final SimpleNode simpleNode = myTree.getNodeFor(event.getPath());
  65
  66         if(simpleNode instanceof AbstractDomElementNode) {
  67           ((AbstractDomElementNode)simpleNode).setExpanded(true);
  68         }
  69       }
  70
  71       public void treeCollapsed(TreeExpansionEvent event) {
  72          final SimpleNode simpleNode = myTree.getNodeFor(event.getPath());
  73
  74         if(simpleNode instanceof AbstractDomElementNode) {
  75           ((AbstractDomElementNode)simpleNode).setExpanded(false);
  76           simpleNode.update();
  77         }
  78       }
  79     });
  80
  81     myDomEventListener = new DomEventListener() {
  82
  83       public void valueChanged(TagValueChangeEvent event) {
  84         super.valueChanged(event);
  85       }
  86
  87       public void elementDefined(ElementDefinedEvent event) {
  88         super.elementDefined(event);
  89       }
  90
  91       public void elementUndefined(ElementUndefinedEvent event) {
  92         super.elementUndefined(event);
  93       }
  94
  95       public void elementChanged(ElementChangedEvent event) {
  96         super.elementChanged(event);
  97       }
  98
  99       public void childAdded(CollectionElementAddedEvent event) {
 100         super.childAdded(event);
 101       }
 102
 103       public void childRemoved(CollectionElementRemovedEvent event) {
 104         super.childRemoved(event);
 105       }
 106
 107       public void eventOccured(DomEvent event) {
 108         myBuilder.updateFromRoot(false);
 109       }
 110     };
 111     myDomManager = rootElement.getManager();
 112     myDomManager.addDomEventListener(myDomEventListener);
 113
 114     myTree.setPopupGroup(getPopupActions(), DOM_MODEL_TREE_VIEW_POPUP);
 115   }
 116
 117   public DomElement getRootElement() {
 118     return myRootElement;
 119   }
 120
 121   protected SimpleTreeStructure getTreeStructure(final DomElement rootDomElement) {
 122     return new DomModelTreeStructure(rootDomElement);
 123   }
 124
 125   public SimpleTreeBuilder getBuilder() {
 126     return myBuilder;
 127   }
 128
 129   public void dispose() {
 130     myDomManager.removeDomEventListener(myDomEventListener);
 131   }
 132
 133   public SimpleTree getTree() {
 134     return myTree;
 135   }
 136
 137   protected ActionGroup getPopupActions() {
 138     DefaultActionGroup group = new DefaultActionGroup();
 139
 140     group.add(ActionManagerEx.getInstance().getAction("DomElementsTreeView.TreePopup"));
 141     group.addSeparator();
 142
 143     group.add(new ExpandAllAction(myTree));
 144     group.add(new CollapseAllAction(myTree));
 145
 146     return group;
 147   }
 148
 149   @Nullable
 150   public Object getData(String dataId) {
 151     if (DOM_MODEL_TREE_VIEW_KEY.equals(dataId)) {
 152       return this;
 153     }
 154     return null;
 155   }
 156
 157   public void setSelectedDomElement(final DomElement domElement) {
 158     if(domElement == null) return;
 159
 160     final java.util.List<SimpleNode> parentsNodes = new ArrayList<SimpleNode>();
 161
 162     SimpleNodeVisitor visitor = new SimpleNodeVisitor() {
 163       public boolean accept(SimpleNode simpleNode) {
 164         if(simpleNode instanceof BaseDomElementNode) {
 165           final DomElement nodeElement = ((AbstractDomElementNode)simpleNode).getDomElement();
 166           if(isParent(nodeElement, domElement)) {
 167              parentsNodes.add(simpleNode);
 168           }
 169         }
 170         return false;
 171       }
 172
 173       private boolean isParent(final DomElement potentialParent, final DomElement domElement) {
 174         DomElement currParent = domElement;
 175         while(currParent != null) {
 176           if(currParent.equals(potentialParent)) return true;
 177
 178           currParent = currParent.getParent();
 179         }
 180         return false;
 181       }
 182     };
 183
 184     getTree().accept(getBuilder(), visitor);
 185     if(parentsNodes.size() > 0) {
 186         getTree().setSelectedNode(getBuilder(), parentsNodes.get(parentsNodes.size()-1), true);
 187     }
 188   };
 189 }
 190