Java XMLLanguage.INSTANCE属性代码示例

@Nullable
public static BreadcrumbsInfoProvider findInfoProvider(@Nullable FileViewProvider viewProvider) {
  BreadcrumbsInfoProvider provider = null;
  if (viewProvider != null) {
    final WebEditorOptions webEditorOptions = WebEditorOptions.getInstance();
    final Language baseLang = viewProvider.getBaseLanguage();
    provider = getInfoProvider(baseLang);
    if (!webEditorOptions.isBreadcrumbsEnabledInXml() && baseLang == XMLLanguage.INSTANCE) return null;
    if (!webEditorOptions.isBreadcrumbsEnabled() && baseLang != XMLLanguage.INSTANCE) return null;
    if (provider == null) {
      for (final Language language : viewProvider.getLanguages()) {
        provider = getInfoProvider(language);
        if (provider != null) {
          break;
        }
      }
    }
  }
  return provider;
}
 

@SuppressWarnings({ "StringEquality" })
    public void initComponent() {
      final Language xmlLang = XMLLanguage.INSTANCE;

//            intentionManager.addAction(new DeleteUnusedParameterFix());
//            intentionManager.addAction(new DeleteUnusedVariableFix());

      final XsltFormattingModelBuilder builder = new XsltFormattingModelBuilder(LanguageFormatting.INSTANCE.forLanguage(xmlLang));
      LanguageFormatting.INSTANCE.addExplicitExtension(xmlLang, builder);

      try {
        // TODO: put this into com.intellij.refactoring.actions.IntroduceParameterAction, just like IntroduceVariableAction
        ActionManager.getInstance().getAction("IntroduceParameter").setInjectedContext(true);
      } catch (Exception e) {
        Logger.getInstance(XsltConfigImpl.class.getName()).error(e);
      }
    }
 

@Override
protected void initTabs(CodeStyleSettings settings) {
  addIndentOptionsTab(settings);
  addTab(new CodeStyleXmlPanel(settings));
  addTab(new XmlArrangementPanel(settings));

  for (CodeStyleSettingsProvider provider : Extensions.getExtensions(CodeStyleSettingsProvider.EXTENSION_POINT_NAME)) {
    if (provider.getLanguage() == XMLLanguage.INSTANCE && !provider.hasSettingsPage()) {
      createTab(provider);
    }
  }
}
 

@Override
@NotNull
public String getElementInfo(@NotNull final PsiElement e) {
  final XmlTag tag = (XmlTag)e;
  final StringBuilder sb = new StringBuilder();

  sb.append(tag.getName());

  final boolean addHtmlInfo = e.getContainingFile().getLanguage() != XMLLanguage.INSTANCE;

  if (addHtmlInfo) {
    final String id_value = tag.getAttributeValue(HtmlUtil.ID_ATTRIBUTE_NAME);
    if (null != id_value) {
      sb.append("#").append(id_value);
    }

    final String class_value = tag.getAttributeValue(HtmlUtil.CLASS_ATTRIBUTE_NAME);
    if (null != class_value) {
      final StringTokenizer tokenizer = new StringTokenizer(class_value, " ");
      while (tokenizer.hasMoreTokens()) {
        sb.append(".").append(tokenizer.nextToken());
      }
    }
  }

  return sb.toString();
}
 

@NotNull
public static Collection<Url> getDebuggableUrls(@Nullable PsiElement context) {
  try {
    OpenInBrowserRequest request = context == null ? null : OpenInBrowserRequest.create(context);
    return request == null || request.getFile().getViewProvider().getBaseLanguage() == XMLLanguage.INSTANCE ? Collections.<Url>emptyList() : getUrls(getProvider(request), request);
  }
  catch (WebBrowserUrlProvider.BrowserException ignored) {
    return Collections.emptyList();
  }
}
 

private static MultiMap<PsiElement, String> detectConflicts(UsageInfo[] usages) {
  final List<PsiElement> nonXmlUsages = new ArrayList<PsiElement>();
  final List<PsiElement> unsupportedUsages = new ArrayList<PsiElement>();
  final List<PsiElement> unambiguousUsages = new ArrayList<PsiElement>();

  for (UsageInfo usage : usages) {
    final PsiElement element = usage.getElement();
    if (element == null) continue;

    if (element.getLanguage() != XMLLanguage.INSTANCE) {
      nonXmlUsages.add(element);
      continue;
    }
    final XmlTag tag = PsiTreeUtil.getParentOfType(element, XmlTag.class);
    final LayoutUsageData usageData = tag != null
                                      ? AndroidInlineUtil.getLayoutUsageData(tag)
                                      : null;
    if (usageData == null) {
      unsupportedUsages.add(element);
      continue;
    }

    if (usageData.getReference().computeTargetElements().length > 1) {
      unambiguousUsages.add(element);
    }
  }
  return AndroidInlineUtil.buildConflicts(nonXmlUsages, unambiguousUsages, unsupportedUsages,
                                          Collections.<PsiElement>emptyList());
}
 

AndroidXmlCodeStylePanel(CodeStyleSettings currentSettings, CodeStyleSettings settings) {
  super(XMLLanguage.INSTANCE, currentSettings, settings);
  myPanel = new JPanel(new BorderLayout());
  myPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
  JPanel centerPanel = new JPanel(new VerticalFlowLayout(VerticalFlowLayout.TOP, 0, 0, true, false));
  myPanel.add(centerPanel, BorderLayout.CENTER);
  myUseCustomSettings = new JBCheckBox("Use custom formatting settings for Android XML files");
  myPanel.add(myUseCustomSettings, BorderLayout.NORTH);

  myCodeStylePanels = new ArrayList<MyFileSpecificPanel>();

  myCodeStylePanels.add(new ManifestCodeStylePanel());
  myCodeStylePanels.add(new LayoutCodeStylePanel());
  myCodeStylePanels.add(new ValueResourcesCodeStylePanel());
  myCodeStylePanels.add(new OtherCodeStylePanel());

  myFileSpecificCodeStylesPanel = new JPanel(new GridLayout((myCodeStylePanels.size() + 1) / 2, 2, 15, 0));
  centerPanel.add(myFileSpecificCodeStylesPanel);

  myUseCustomSettings.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
      UIUtil.setEnabled(myFileSpecificCodeStylesPanel, myUseCustomSettings.isSelected(), true);
    }
  });

  for (MyFileSpecificPanel panel : myCodeStylePanels) {
    final JPanel titledPanel = new JPanel(new BorderLayout());
    titledPanel.setBorder(IdeBorderFactory.createTitledBorder(panel.getTitle()));
    titledPanel.add(panel, BorderLayout.CENTER);
    myFileSpecificCodeStylesPanel.add(titledPanel);
  }
}
 

public boolean isEngagedToFormat(PsiElement context) {
  final PsiFile file = context.getContainingFile();
  if (file == null) {
    return false;
  } else if (file.getFileType() == XmlFileType.INSTANCE
          && file.getLanguage() == XMLLanguage.INSTANCE) {

    return XsltSupport.isXsltFile(file);
  }
  return false;
}
 

public void advance() {
  final IElementType tokenType = myDelegate.getTokenType();

  if (tokenType == XmlElementType.XML_COMMENT_CHARACTERS) {
    scanWordsInToken(UsageSearchContext.IN_COMMENTS, false, false);
    advanceTodoItemCountsInToken();
  } else if (tokenType == XmlElementType.XML_ATTRIBUTE_VALUE_TOKEN ||
      tokenType == XmlElementType.XML_NAME ||
      tokenType == XmlElementType.XML_TAG_NAME
     ) {
    scanWordsInToken(UsageSearchContext.IN_PLAIN_TEXT | UsageSearchContext.IN_FOREIGN_LANGUAGES, tokenType == XmlElementType.XML_ATTRIBUTE_VALUE_TOKEN,
                     false);
  } else if (tokenType.getLanguage() != XMLLanguage.INSTANCE &&
    tokenType.getLanguage() != Language.ANY         
  ) {
    boolean inComments = CacheUtil.isInComments(tokenType);
    scanWordsInToken((inComments)?UsageSearchContext.IN_COMMENTS:UsageSearchContext.IN_PLAIN_TEXT | UsageSearchContext.IN_FOREIGN_LANGUAGES, true,
                     false);
    
    if (inComments) advanceTodoItemCountsInToken();
  }
  else if (!XmlFilterLexer.ourNoWordsTokenSet.contains(tokenType)) {
    scanWordsInToken(UsageSearchContext.IN_PLAIN_TEXT, false, false);
  }

  myDelegate.advance();
}
 

@Override
public String generateDoc(PsiElement element, @Nullable PsiElement originalElement) {
  if (originalElement == null) return null;
  if (originalElement.getLanguage() == XMLLanguage.INSTANCE || DevKitInspectionBase.isPluginXml(originalElement.getContainingFile())) {
    final PsiElement context = element.getContext();
    String fqn = null;
    if (originalElement instanceof XmlToken && ((XmlToken)originalElement).getTokenType() == XmlTokenType.XML_NAME) {
      PsiElement attr;
      PsiElement tag;
      if (context != null
          && (attr = context.getParent()) instanceof XmlAttribute
          && (tag = attr.getParent()) instanceof XmlTag) {
        final String interfaceFqn = ((XmlTag)tag).getAttributeValue("interface");
        final String beanClassFqn = ((XmlTag)tag).getAttributeValue("beanClass");
        fqn = interfaceFqn == null ? beanClassFqn : interfaceFqn;
      }
    }

    if (fqn != null) {
      final Project project = element.getProject();
      final PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass(fqn, GlobalSearchScope.allScope(project));
      if (psiClass != null) {
        return new JavaDocumentationProvider().generateExternalJavadoc(psiClass);
      }
    }

  }
  return null;
}
 

private static Language getLanguage(PsiElement element) {
  Language lang = element.getLanguage();
  if (lang == XMLLanguage.INSTANCE) {
    PsiElement parent = element.getParent();
    lang = parent.getLanguage();
  }
  return lang;
}
 

static boolean isTagWithEmptyEndNotAllowed(final XmlTag tag) {
  String tagName = tag.getName();
  if (tag instanceof HtmlTag) tagName = tagName.toLowerCase();

  Language language = tag.getLanguage();
  return ourTagsWithEmptyEndsNotAllowed.contains(tagName) && language != XMLLanguage.INSTANCE ||
         language == HTMLLanguage.INSTANCE && !HtmlUtil.isSingleHtmlTagL(tagName) && tagName.indexOf(':') == -1;
}
 

protected boolean useMyFormatter(final Language myLanguage, final Language childLanguage, final PsiElement childPsi) {
  if (myLanguage == childLanguage ||
      childLanguage == HTMLLanguage.INSTANCE ||
      childLanguage == XHTMLLanguage.INSTANCE ||
      childLanguage == XMLLanguage.INSTANCE) {
    return true;
  }
  final FormattingModelBuilder childFormatter = LanguageFormatting.INSTANCE.forLanguage(childLanguage);
  return childFormatter == null ||
         childFormatter instanceof DelegatingFormattingModelBuilder &&
         ((DelegatingFormattingModelBuilder)childFormatter).dontFormatMyModel();
}
 

private HybrisXmlFileType() {
    super(XMLLanguage.INSTANCE);
}
 

private MdFileType() {
    super(XMLLanguage.INSTANCE);
}