java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/projectRoot/FacetEditorFacadeImpl.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 package com.intellij.openapi.roots.ui.configuration.projectRoot;
  18
  19 import com.intellij.facet.*;
  20 import com.intellij.facet.impl.ProjectFacetsConfigurator;
  21 import com.intellij.facet.impl.ui.FacetEditorFacade;
  22 import com.intellij.facet.impl.ui.FacetTreeModel;
  23 import com.intellij.openapi.diagnostic.Logger;
  24 import com.intellij.openapi.module.Module;
  25 import com.intellij.openapi.module.ModuleType;
  26 import com.intellij.openapi.ui.MasterDetailsComponent;
  27 import com.intellij.openapi.ui.NamedConfigurable;
  28 import org.jetbrains.annotations.Nullable;
  29
  30 import javax.swing.tree.TreeNode;
  31 import java.util.*;
  32
  33 /**
  34  * @author nik
  35  */
  36 public class FacetEditorFacadeImpl implements FacetEditorFacade {
  37   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.roots.ui.configuration.projectRoot.FacetEditorFacadeImpl");
  38   private final ModuleStructureConfigurable myStructureConfigurable;
  39   private final Runnable myTreeUpdater;
  40   private final Map<Facet, MasterDetailsComponent.MyNode> myNodes = new HashMap<Facet, MasterDetailsComponent.MyNode>();
  41   private final Map<Facet, FacetConfigurable> myConfigurables = new HashMap<Facet, FacetConfigurable>();
  42
  43   public FacetEditorFacadeImpl(final ModuleStructureConfigurable structureConfigurable, final Runnable treeUpdater) {
  44     myStructureConfigurable = structureConfigurable;
  45     myTreeUpdater = treeUpdater;
  46   }
  47
  48   public boolean addFacetsNodes(final Module module, final MasterDetailsComponent.MyNode moduleNode) {
  49     boolean facetsExist = false;
  50
  51     getFacetConfigurator().addFacetInfos(module);
  52
  53     final FacetModel facetModel = getFacetConfigurator().getFacetModel(module);
  54     for (Facet facet : facetModel.getSortedFacets()) {
  55       addFacetNode(facet, moduleNode);
  56       facetsExist = true;
  57     }
  58
  59     return facetsExist;
  60   }
  61
  62   private MasterDetailsComponent.MyNode addFacetNode(final Facet facet, final MasterDetailsComponent.MyNode moduleNode) {
  63     final MasterDetailsComponent.MyNode existing = findFacetNode(facet, moduleNode);
  64     if (existing != null) return existing;
  65
  66     final FacetConfigurable facetConfigurable = getOrCreateConfigurable(facet);
  67     final MasterDetailsComponent.MyNode facetNode = new MasterDetailsComponent.MyNode(facetConfigurable);
  68     myNodes.put(facet, facetNode);
  69     MasterDetailsComponent.MyNode parent = moduleNode;
  70     final Facet underlyingFacet = facet.getUnderlyingFacet();
  71     if (underlyingFacet != null) {
  72       parent = myNodes.get(underlyingFacet);
  73       LOG.assertTrue(parent != null);
  74     }
  75     myStructureConfigurable.addNode(facetNode, parent);
  76     return facetNode;
  77   }
  78
  79   public FacetConfigurable getOrCreateConfigurable(final Facet facet) {
  80     FacetConfigurable configurable = myConfigurables.get(facet);
  81     if (configurable == null) {
  82       configurable = new FacetConfigurable(facet, getFacetConfigurator(), myTreeUpdater);
  83       myConfigurables.put(facet, configurable);
  84     }
  85     return configurable;
  86   }
  87
  88   @Nullable
  89   private static MasterDetailsComponent.MyNode findFacetNode(final Facet facet, final MasterDetailsComponent.MyNode moduleNode) {
  90     for (int i = 0; i < moduleNode.getChildCount(); i++) {
  91       final TreeNode node = moduleNode.getChildAt(i);
  92       if (node instanceof MasterDetailsComponent.MyNode) {
  93         final MasterDetailsComponent.MyNode configNode = (MasterDetailsComponent.MyNode)node;
  94         final NamedConfigurable config = configNode.getConfigurable();
  95         if (config instanceof FacetConfigurable) {
  96           final Facet existingFacet = ((FacetConfigurable)config).getEditableObject();
  97           if (existingFacet != null && existingFacet.equals(facet)) {
  98             return configNode;
  99           }
 100         }
 101       }
 102     }
 103
 104     return null;
 105   }
 106
 107   public boolean nodeHasFacetOfType(final FacetInfo facet, FacetTypeId typeId) {
 108     final Module selectedModule = getSelectedModule();
 109     if (selectedModule == null) {
 110       return false;
 111     }
 112     final FacetTreeModel facetTreeModel = getFacetConfigurator().getTreeModel(selectedModule);
 113     return facetTreeModel.hasFacetOfType(facet, typeId);
 114   }
 115
 116   public void createFacet(final FacetInfo parent, FacetType type, final String name) {
 117     Module module = getSelectedModule();
 118
 119     final Facet facet = getFacetConfigurator().createAndAddFacet(module, type, name, parent);
 120     final MasterDetailsComponent.MyNode node = addFacetNode(facet, myStructureConfigurable.findModuleNode(module));
 121     myStructureConfigurable.selectNodeInTree(node);
 122   }
 123
 124   public Collection<FacetInfo> getFacetsByType(final FacetType<?,?> type) {
 125     final Module selectedModule = getSelectedModule();
 126     if (selectedModule == null) return Collections.emptyList();
 127     final FacetModel facetModel = getFacetConfigurator().getFacetModel(selectedModule);
 128     final Collection<? extends Facet> facets = facetModel.getFacetsByType(type.getId());
 129
 130     final ArrayList<FacetInfo> infos = new ArrayList<FacetInfo>();
 131     for (Facet facet : facets) {
 132       final FacetInfo facetInfo = getFacetConfigurator().getFacetInfo(facet);
 133       if (facetInfo != null) {
 134         infos.add(facetInfo);
 135       }
 136     }
 137     return infos;
 138   }
 139
 140   @Nullable
 141   public FacetInfo getParent(final FacetInfo facetInfo) {
 142     final Module module = getFacetConfigurator().getFacet(facetInfo).getModule();
 143     return getFacetConfigurator().getTreeModel(module).getParent(facetInfo);
 144   }
 145
 146   private ProjectFacetsConfigurator getFacetConfigurator() {
 147     return myStructureConfigurable.getFacetConfigurator();
 148   }
 149
 150   @Nullable
 151   private Facet getSelectedFacet() {
 152     final Object selectedObject = myStructureConfigurable.getSelectedObject();
 153     if (selectedObject instanceof Facet) {
 154       return (Facet)selectedObject;
 155     }
 156     return null;
 157   }
 158
 159   @Nullable
 160   private Module getSelectedModule() {
 161     final Object selected = myStructureConfigurable.getSelectedObject();
 162     if (selected instanceof Module) {
 163       return (Module)selected;
 164     }
 165     if (selected instanceof Facet) {
 166       return ((Facet)selected).getModule();
 167     }
 168     return null;
 169   }
 170
 171   @Nullable
 172   public ModuleType getSelectedModuleType() {
 173     final Module module = getSelectedModule();
 174     return module != null ? module.getModuleType() : null;
 175   }
 176
 177   @Nullable
 178   public FacetInfo getSelectedFacetInfo() {
 179     final Facet facet = getSelectedFacet();
 180     return facet != null ? getFacetConfigurator().getFacetInfo(facet) : null;
 181   }
 182
 183   public void clearMaps() {
 184     myConfigurables.clear();
 185     myNodes.clear();
 186   }
 187 }