import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private static void addContextNode(MultiMap<TemplateContextType, TemplateContextType> hierarchy,
                                   CheckedTreeNode parent,
                                   TemplateContextType type, TemplateContext context) {
  final Collection<TemplateContextType> children = hierarchy.get(type);
  final String name = UIUtil.removeMnemonic(type.getPresentableName());
  final CheckedTreeNode node = new CheckedTreeNode(Pair.create(children.isEmpty() ? type : null, name));
  parent.add(node);

  if (children.isEmpty()) {
    node.setChecked(context.isExplicitlyEnabled(type));
  }
  else {
    for (TemplateContextType child : children) {
      addContextNode(hierarchy, node, child, context);
    }
    final CheckedTreeNode other = new CheckedTreeNode(Pair.create(type, "Other"));
    other.setChecked(context.isExplicitlyEnabled(type));
    node.add(other);
  }
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
Map<TemplateContextType, Boolean> getDifference(@Nullable TemplateContext defaultContext) {
  Map<TemplateContextType, Boolean> result = ContainerUtil.newLinkedHashMap();
  synchronized (myContextStates) {
    //noinspection NestedSynchronizedStatement
    synchronized (defaultContext == null ? myContextStates : defaultContext.myContextStates) {
      for (TemplateContextType contextType : TemplateManagerImpl.getAllContextTypes()) {
        Boolean ownValue = getOwnValue(contextType);
        if (ownValue != null) {
          if (defaultContext == null || isEnabled(contextType) != defaultContext.isEnabled(contextType)) {
            result.put(contextType, ownValue);
          }
        }
      }
    }
  }
  return result;
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
@Override
public void performCopy(@NotNull DataContext dataContext) {
  final Set<TemplateImpl> templates = myConfigurable.getSelectedTemplates().keySet();


  CopyPasteManager.getInstance().setContents(new StringSelection(StringUtil.join(templates, new Function<TemplateImpl, String>() {
    @Override
    public String fun(TemplateImpl template) {
      TemplateContext zeroContext = new TemplateContext();
      for (TemplateContextType type : TemplateContextType.EP_NAME.getExtensions()) {
        zeroContext.setEnabled(type, false);
      }
      return JDOMUtil.writeElement(TemplateSettings.serializeTemplate(template, zeroContext));
    }
  }, SystemProperties.getLineSeparator())));
  
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private void addContextNode(MultiMap<TemplateContextType, TemplateContextType> hierarchy,
                            CheckedTreeNode parent,
                            TemplateContextType type) {
  final Collection<TemplateContextType> children = hierarchy.get(type);
  final String name = UIUtil.removeMnemonic(type.getPresentableName());
  final CheckedTreeNode node = new CheckedTreeNode(Pair.create(children.isEmpty() ? type : null, name));
  parent.add(node);

  if (children.isEmpty()) {
    node.setChecked(myContext.get(type));
  }
  else {
    for (TemplateContextType child : children) {
      addContextNode(hierarchy, node, child);
    }
    final CheckedTreeNode other = new CheckedTreeNode(Pair.create(type, "Other"));
    other.setChecked(myContext.get(type));
    node.add(other);
  }
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private void createTemplateEditor(final TemplateImpl template,
                                  String shortcut,
                                  Map<TemplateOptionalProcessor, Boolean> options,
                                  Map<TemplateContextType, Boolean> context) {
  myCurrentTemplateEditor = new LiveTemplateSettingsEditor(template, shortcut, options, context, new Runnable() {
    @Override
    public void run() {
      DefaultMutableTreeNode node = getNode(getSingleSelectedIndex());
      if (node != null) {
        ((DefaultTreeModel)myTree.getModel()).nodeChanged(node);
        TemplateSettings.getInstance().setLastSelectedTemplate(template.getGroupName(), template.getKey());
      }
    }
  }, TemplateSettings.getInstance().getTemplate(template.getKey(), template.getGroupName()) != null);
  for (Component component : myDetailsPanel.getComponents()) {
    if (component instanceof LiveTemplateSettingsEditor) {
      myDetailsPanel.remove(component);
    }
  }

  myDetailsPanel.add(myCurrentTemplateEditor, TEMPLATE_SETTINGS);
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
Map<TemplateContextType, Boolean> getDifference(@Nullable TemplateContext defaultContext) {
  Map<TemplateContextType, Boolean> result = ContainerUtil.newLinkedHashMap();
  synchronized (myContextStates) {
    //noinspection NestedSynchronizedStatement
    synchronized (defaultContext == null ? myContextStates : defaultContext.myContextStates) {
      for (TemplateContextType contextType : TemplateManagerImpl.getAllContextTypes()) {
        String context = contextType.getContextId();
        Boolean myStateInContext = myContextStates.get(context);
        if (myStateInContext != null && differsFromDefault(defaultContext, context, myStateInContext)) {
          result.put(contextType, myStateInContext);
        }
      }
    }
  }
  return result;
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
Map<TemplateContextType, Boolean> getDifference(@Nullable TemplateContext defaultContext) {
  Map<TemplateContextType, Boolean> result = ContainerUtil.newLinkedHashMap();
  synchronized (myContextStates) {
    //noinspection NestedSynchronizedStatement
    synchronized (defaultContext == null ? myContextStates : defaultContext.myContextStates) {
      for (TemplateContextType contextType : TemplateContextType.EP_NAME.getExtensions()) {
        String context = contextType.getContextId();
        Boolean myStateInContext = myContextStates.get(context);
        if (myStateInContext != null && differsFromDefault(defaultContext, context, myStateInContext)) {
          result.put(contextType, myStateInContext);
        }
      }
    }
  }
  return result;
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
public void testLiveTemplate() throws Throwable {
  final Template template = TemplateManager.getInstance(getProject()).createTemplate("foo", "zzz");
  template.addTextSegment("FooFactory.createFoo()");
  final SmartCompletionContextType completionContextType =
    ContainerUtil.findInstance(TemplateContextType.EP_NAME.getExtensions(), SmartCompletionContextType.class);
  ((TemplateImpl)template).getTemplateContext().setEnabled(completionContextType, true);
  CodeInsightTestUtil.addTemplate(template, myTestRootDisposable);
  doTest();
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private List<TemplateContextType> getApplicableContexts() {
  ArrayList<TemplateContextType> result = new ArrayList<TemplateContextType>();
  for (TemplateContextType type : TemplateManagerImpl.getAllContextTypes()) {
    if (myContext.isExplicitlyEnabled(type)) {
      result.add(type);
    }
  }
  return result;
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private boolean isExpandableFromEditor() {
  boolean hasNonExpandable = false;
  for (TemplateContextType type : getApplicableContexts()) {
    if (type.isExpandableFromEditor()) {
      return true;
    }
    hasNonExpandable = true;
  }
  
  return !hasNonExpandable;
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
public boolean isEnabled(TemplateContextType contextType) {
  synchronized (myContextStates) {
    Boolean storedValue = getOwnValue(contextType);
    if (storedValue == null) {
      TemplateContextType baseContextType = contextType.getBaseContextType();
      if (baseContextType != null && !(baseContextType instanceof EverywhereContextType)) {
        return isEnabled(baseContextType);
      }
      return false;
    }
    return storedValue.booleanValue();
  }
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
void writeTemplateContext(Element element, @Nullable TemplateContext defaultContext) throws WriteExternalException {
  Map<TemplateContextType, Boolean> diff = getDifference(defaultContext);
  for (TemplateContextType type : diff.keySet()) {
    Element optionElement = new Element("option");
    optionElement.setAttribute("name", type.getContextId());
    optionElement.setAttribute("value", diff.get(type).toString());
    element.addContent(optionElement);
  }
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private static Document createDocument(CharSequence text, @Nullable TemplateContext context, Project project) {
  if (context != null) {
    for (TemplateContextType type : TemplateManagerImpl.getAllContextTypes()) {
      if (context.isExplicitlyEnabled(type)) {
        return type.createDocument(text, project);
      }
    }
  }

  return EditorFactory.getInstance().createDocument(text);
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
public static void setHighlighter(Editor editor, @Nullable TemplateContext templateContext) {
  SyntaxHighlighter highlighter = null;
  if (templateContext != null) {
    for(TemplateContextType type: TemplateManagerImpl.getAllContextTypes()) {
      if (templateContext.isEnabled(type)) {
        highlighter = type.createHighlighter();
        if (highlighter != null) break;
      }
    }
  }
  setHighlighter((EditorEx)editor, highlighter);
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
public EditVariableDialog(Editor editor, Component parent, ArrayList<Variable> variables, List<TemplateContextType> contextTypes) {
  super(parent, true);
  myContextTypes = contextTypes;
  setButtonsMargin(null);
  myVariables = variables;
  myEditor = editor;
  init();
  setTitle(CodeInsightBundle.message("templates.dialog.edit.variables.title"));
  setOKButtonText(CommonBundle.getOkButtonText());
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
@NotNull
private Template createJsonTemplate(@NotNull String name, @NotNull String group, @NotNull String text) {
  final TemplateManager templateManager = TemplateManager.getInstance(getProject());
  final Template template = templateManager.createTemplate(name, group, text);

  final TemplateContextType context = ContainerUtil.findInstance(TemplateContextType.EP_NAME.getExtensions(), JsonContextType.class);
  assertNotNull(context);
  ((TemplateImpl)template).getTemplateContext().setEnabled(context, true);

  CodeInsightTestUtil.addTemplate(template, myTestRootDisposable);
  return template;
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
public void testLiveTemplate() throws Throwable {
  final Template template = TemplateManager.getInstance(getProject()).createTemplate("foo", "zzz");
  template.addTextSegment("FooFactory.createFoo()");
  final SmartCompletionContextType completionContextType =
    ContainerUtil.findInstance(TemplateContextType.EP_NAME.getExtensions(), SmartCompletionContextType.class);
  ((TemplateImpl)template).getTemplateContext().setEnabled(completionContextType, true);
  TemplateSettings.getInstance().addTemplate(template);
  try {
    doTest();
  }
  finally {
    TemplateSettings.getInstance().removeTemplate(template);
  }
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private List<TemplateContextType> getApplicableContexts() {
  ArrayList<TemplateContextType> result = new ArrayList<TemplateContextType>();
  for (TemplateContextType type : myContext.keySet()) {
    if (myContext.get(type).booleanValue()) {
      result.add(type);
    }
  }
  return result;
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private void updateHighlighter() {
  List<TemplateContextType> applicableContexts = getApplicableContexts();
  if (!applicableContexts.isEmpty()) {
    TemplateContext contextByType = new TemplateContext();
    contextByType.setEnabled(applicableContexts.get(0), true);
    TemplateEditorUtil.setHighlighter(myTemplateEditor, contextByType);
    return;
  }
  ((EditorEx) myTemplateEditor).repaint(0, myTemplateEditor.getDocument().getTextLength());
}
 

import com.intellij.codeInsight.template.TemplateContextType; //导入依赖的package包/类
private boolean areContextsEqual(final TemplateImpl newTemplate, final TemplateImpl originalTemplate) {
  Map<TemplateContextType, Boolean> templateContext = getTemplateContext(newTemplate);
  for (TemplateContextType processor : templateContext.keySet()) {
    if (originalTemplate.getTemplateContext().isEnabled(processor) != templateContext.get(processor).booleanValue())
      return false;
  }
  return true;
}