Java StdFileTypes.GUI_DESIGNER_FORM属性代码示例

@NotNull
static Pair<Charset, String> checkHardcodedCharsetFileType(@NotNull VirtualFile virtualFile) {
  FileType fileType = virtualFile.getFileType();
  if (fileType.isBinary()) return Pair.create(null, "binary file");
  // in lesser IDEs all special file types are plain text so check for that first
  if (fileType == FileTypes.PLAIN_TEXT) return Pair.create(null, null);
  if (fileType == StdFileTypes.GUI_DESIGNER_FORM) return Pair.create(CharsetToolkit.UTF8_CHARSET, "IDEA GUI Designer form");
  if (fileType == StdFileTypes.IDEA_MODULE) return Pair.create(CharsetToolkit.UTF8_CHARSET, "IDEA module file");
  if (fileType == StdFileTypes.IDEA_PROJECT) return Pair.create(CharsetToolkit.UTF8_CHARSET, "IDEA project file");
  if (fileType == StdFileTypes.IDEA_WORKSPACE) return Pair.create(CharsetToolkit.UTF8_CHARSET, "IDEA workspace file");

  if (fileType == StdFileTypes.PROPERTIES) return Pair.create(virtualFile.getCharset(), ".properties file");

  if (fileType == StdFileTypes.XML || fileType == StdFileTypes.JSPX) {
    return Pair.create(virtualFile.getCharset(), "XML file");
  }
  return Pair.create(null, null);
}
 

private static boolean processReferencesInFiles(List<PsiFile> files,
                                                PsiManager psiManager, String baseName,
                                                PsiElement element,
                                                LocalSearchScope filterScope,
                                                Processor<PsiReference> processor) {
  psiManager.startBatchFilesProcessingMode();

  try {
    for (PsiFile file : files) {
      ProgressManager.checkCanceled();

      if (file.getFileType() != StdFileTypes.GUI_DESIGNER_FORM) continue;
      if (!processReferences(processor, file, baseName, element, filterScope)) return false;
    }
  }
  finally {
    psiManager.finishBatchFilesProcessingMode();
  }
  return true;
}
 

@Nullable
public UsageType getUsageType(PsiElement element) {
  final PsiFile psiFile = element.getContainingFile();
  if (psiFile.getFileType() == StdFileTypes.GUI_DESIGNER_FORM) {
    return FORM_USAGE_TYPE;
  }
  return null;
}
 

private static boolean processReferencesInUIForms(final Processor<PsiReference> processor,
                                                  PsiManager psiManager,
                                                  final Property property,
                                                  final GlobalSearchScope globalSearchScope,
                                                  final LocalSearchScope filterScope) {
  final Project project = psiManager.getProject();

  final GlobalSearchScope scope = GlobalSearchScope.projectScope(project).intersectWith(globalSearchScope);
  String name = ApplicationManager.getApplication().runReadAction(new Computable<String>() {
    @Override
    public String compute() {
      return property.getName();
    }
  });
  if (name == null) return true;

  psiManager.startBatchFilesProcessingMode();

  try {
    CommonProcessors.CollectProcessor<VirtualFile> collector = new CommonProcessors.CollectProcessor<VirtualFile>() {
      @Override
      protected boolean accept(VirtualFile virtualFile) {
        return virtualFile.getFileType() == StdFileTypes.GUI_DESIGNER_FORM;
      }
    };
    ((PsiSearchHelperImpl)PsiSearchHelper.SERVICE.getInstance(project)).processFilesWithText(
      scope, UsageSearchContext.IN_PLAIN_TEXT, true, name, collector
    );
    
    for (final VirtualFile vfile:collector.getResults()) {
      ProgressManager.checkCanceled();

      PsiFile file = ApplicationManager.getApplication().runReadAction(new Computable<PsiFile>() {
        @Override
        public PsiFile compute() {
          return PsiManager.getInstance(project).findFile(vfile);
        }
      });
      if (!processReferences(processor, file, name, property, filterScope)) return false;
    }
  }
  finally {
    psiManager.finishBatchFilesProcessingMode();
  }

  return true;
}
 

@NotNull
@Override
public FileBasedIndex.InputFilter getInputFilter() {
  return new DefaultFileTypeSpecificInputFilter(StdFileTypes.GUI_DESIGNER_FORM);
}
 

@NotNull
public Collection<AbstractTreeNode> modify(@NotNull AbstractTreeNode parent, @NotNull Collection<AbstractTreeNode> children, ViewSettings settings) {
  if (parent.getValue() instanceof Form) return children;

  // Optimization. Check if there are any forms at all.
  boolean formsFound = false;
  for (AbstractTreeNode node : children) {
    if (node.getValue() instanceof PsiFile) {
      PsiFile file = (PsiFile)node.getValue();
      if (file.getFileType() == StdFileTypes.GUI_DESIGNER_FORM) {
        formsFound = true;
        break;
      }
    }
  }

  if (!formsFound) return children;

  Collection<AbstractTreeNode> result = new LinkedHashSet<AbstractTreeNode>(children);
  ProjectViewNode[] copy = children.toArray(new ProjectViewNode[children.size()]);
  for (ProjectViewNode element : copy) {
    PsiClass psiClass = null;
    if (element.getValue() instanceof PsiClass) {
      psiClass = (PsiClass)element.getValue();
    }
    else if (element.getValue() instanceof PsiClassOwner) {
      final PsiClass[] psiClasses = ((PsiClassOwner) element.getValue()).getClasses();
      if (psiClasses.length == 1) {
        psiClass = psiClasses[0];
      }
    }
    if (psiClass == null) continue;
    String qName = psiClass.getQualifiedName();
    if (qName == null) continue;
    List<PsiFile> forms;
    try {
      forms = FormClassIndex.findFormsBoundToClass(myProject, qName);
    }
    catch (ProcessCanceledException e) {
      continue;
    }
    Collection<BasePsiNode<? extends PsiElement>> formNodes = findFormsIn(children, forms);
    if (!formNodes.isEmpty()) {
      Collection<PsiFile> formFiles = convertToFiles(formNodes);
      Collection<BasePsiNode<? extends PsiElement>> subNodes = new ArrayList<BasePsiNode<? extends PsiElement>>();
      //noinspection unchecked
      subNodes.add((BasePsiNode<? extends PsiElement>) element);
      subNodes.addAll(formNodes);
      result.add(new FormNode(myProject, new Form(psiClass, formFiles), settings, subNodes));
      result.remove(element);
      result.removeAll(formNodes);
    }
  }
  return result;
}
 

public boolean isValid(){
  //TODO[anton,vova] fire when changed
  return
    FileDocumentManager.getInstance().getDocument(myFile) != null &&
    myFile.getFileType() == StdFileTypes.GUI_DESIGNER_FORM;
}
 

public boolean accept(@NotNull final Project project, @NotNull final VirtualFile file){
  return
    file.getFileType() == StdFileTypes.GUI_DESIGNER_FORM &&
    !StdFileTypes.GUI_DESIGNER_FORM.isBinary() &&
    (ModuleUtil.findModuleForFile(file, project) != null || file instanceof LightVirtualFile);
}