com.intellij.ide.structureView.StructureViewBuilder Java Examples

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile)
{
	if(psiFile instanceof CSharpFileImpl)
	{
		return new TreeBasedStructureViewBuilder()
		{
			@Nonnull
			@Override
			public StructureViewModel createStructureViewModel(@Nullable Editor editor)
			{
				return new CSharpStructureViewModel(psiFile, editor);
			}
		};
	}
	else
	{
		return null;
	}
}
 

@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  if (!(psiFile instanceof HaxeFile)) {
    return null;
  }
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new HaxeStructureViewModel(psiFile, editor);
    }

    @Override
    public boolean isRootNodeShown() {
      return false;
    }
  };
}
 

public void testBasics() {
    assertEquals(CsvTableEditor.EDITOR_NAME, fileEditor.getName());
    assertEquals(fileEditor, fileEditor.getCurrentLocation());
    assertInstanceOf(fileEditor.getState(FileEditorStateLevel.FULL), CsvTableEditorState.class);
    assertInstanceOf(fileEditor.getState(FileEditorStateLevel.NAVIGATION), CsvTableEditorState.class);
    assertInstanceOf(fileEditor.getState(FileEditorStateLevel.UNDO), CsvTableEditorState.class);

    CsvTableEditorState myState = new CsvTableEditorState();
    fileEditor.setState(myState);
    assertEquals(myState, fileEditor.getState(FileEditorStateLevel.FULL));

    assertEquals(false, fileEditor.isModified());
    assertEquals(true, fileEditor.isValid());
    assertEquals(null, fileEditor.getBackgroundHighlighter());

    StructureViewBuilder structureViewBuilder = StructureViewBuilder.PROVIDER.getStructureViewBuilder(myFixture.getFile().getFileType(), myFixture.getFile().getVirtualFile(), this.getProject());
    assertInstanceOf(fileEditor.getStructureViewBuilder(), structureViewBuilder.getClass());

    assertEquals(myFixture.getFile().getVirtualFile(), fileEditor.getFile());
    assertEquals(this.getProject(), fileEditor.getProject());
    assertNotNull(fileEditor.getDataHandler());
    assertNotNull(fileEditor.getComponent());
    assertEquals(fileEditor.getTable(), fileEditor.getPreferredFocusedComponent());
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new ProtoStructureViewModel((ProtoPsiFileRoot) psiFile, editor);
        }

        @Override
        public boolean isRootNodeShown() {
            return false;
        }
    };
}
 

@Nullable
public static FileStructurePopup createPopup(@Nonnull Project project, @Nonnull FileEditor fileEditor) {
  PsiDocumentManager.getInstance(project).commitAllDocuments();
  StructureViewBuilder builder = fileEditor.getStructureViewBuilder();
  if (builder == null) return null;
  StructureView structureView;
  StructureViewModel treeModel;
  if (builder instanceof TreeBasedStructureViewBuilder) {
    structureView = null;
    treeModel = ((TreeBasedStructureViewBuilder)builder).createStructureViewModel(EditorUtil.getEditorEx(fileEditor));
  }
  else {
    structureView = builder.createStructureView(fileEditor, project);
    treeModel = createStructureViewModel(project, fileEditor, structureView);
  }
  if (treeModel instanceof PlaceHolder) {
    //noinspection unchecked
    ((PlaceHolder)treeModel).setPlace(TreeStructureUtil.PLACE);
  }
  FileStructurePopup popup = new FileStructurePopup(project, fileEditor, treeModel);
  if (structureView != null) Disposer.register(popup, structureView);
  return popup;
}
 

@Nullable
private StructureViewBuilder getBuilder(@Nonnull PsiFile psiFile, @Nonnull Language language) {
  FileViewProvider viewProvider = psiFile.getViewProvider();
  Language baseLanguage = viewProvider.getBaseLanguage();
  PsiFile psi = viewProvider.getPsi(language);
  if (psi == null) return null;
  if (language == baseLanguage) return createMainBuilder(psi);
  if (!isAcceptableBaseLanguageFile(psi)) return null;
  PsiStructureViewFactory factory = LanguageStructureViewBuilder.INSTANCE.forLanguage(language);
  return factory == null ? null : factory.getStructureViewBuilder(psi);
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public com.intellij.ide.structureView.StructureViewModel createStructureViewModel(Editor editor) {
            return new XQueryStructureViewModel(psiFile).withSuitableClasses(
                    XQueryFunctionDecl.class, XQueryVarDecl.class, XQueryQueryBody.class
            );
        }
    };
}
 

@Nullable
 @Override
 public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
     return new TreeBasedStructureViewBuilder() {
@NotNull
@Override
public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
	VirtualFile grammarFile = psiFile.getVirtualFile();
	if ( grammarFile==null || !grammarFile.getName().endsWith(".g4") ) {
		return new StructureViewModelBase(psiFile, new DummyViewTreeElement(psiFile));
	}
             return new ANTLRv4StructureViewModel((ANTLRv4FileRoot)psiFile);
}
     };
 }
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new BuckStructureViewModel(psiFile);
    }
  };
}
 

@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new ThriftStructureViewModel(psiFile);
    }

    @Override
    public boolean isRootNodeShown() {
      return false;
    }
  };
}
 

public String getQualifiedName() {
  String presentableUrl = myFile.getPresentableUrl();
  if (myFile.isDirectory()) return presentableUrl;

  PsiDocumentManager.getInstance(myProject).commitAllDocuments();
  final PsiFile psiFile = PsiManager.getInstance(myProject).findFile(myFile);

  if (psiFile == null) return presentableUrl;

  StructureViewBuilder builder = LanguageStructureViewBuilder.INSTANCE.getStructureViewBuilder(psiFile);
  if (builder instanceof TreeBasedStructureViewBuilder) {
    StructureViewModel model = ((TreeBasedStructureViewBuilder)builder).createStructureViewModel(null);
    Object element;
    try {
      element = model.getCurrentEditorElement();
    }
    finally {
      model.dispose();
    }
    if (element instanceof NavigationItem) {
      ItemPresentation presentation = ((NavigationItem)element).getPresentation();
      if (presentation != null) {
        presentableUrl = ((NavigationItem)element).getName() + " " + presentation.getLocationString();
      }
    }
  }

  return IdeBundle.message("bookmark.file.X.line.Y", presentableUrl, getLine() + 1);
}
 

@Override
@Nullable
public StructureViewBuilder getStructureViewBuilder(@Nonnull final FileType fileType, @Nonnull final VirtualFile file, @Nonnull final Project project) {
  if (!(fileType instanceof LanguageFileType)) return null;

  final PsiFile psiFile = PsiManager.getInstance(project).findFile(file);
  if (psiFile == null) return null;

  final PsiStructureViewFactory factory = LanguageStructureViewBuilder.INSTANCE.forLanguage(psiFile.getLanguage());
  return factory == null ?  null : factory.getStructureViewBuilder(psiFile);
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new CsvStructureViewModel(psiFile);
        }
    };
}
 

public StructureViewBuilder getStructureViewBuilder() {
  final TextEditor textEditor = myPanel.getFileEditor();
  if (textEditor != null) {
    return textEditor.getStructureViewBuilder();
  }
  return null;
}
 

@Override
@Nonnull
public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
  List<StructureViewComposite.StructureViewDescriptor> viewDescriptors = new ArrayList<>();
  PsiFile psiFile = ObjectUtils.notNull(PsiManager.getInstance(myProject).findFile(myVirtualFile));
  for (Language language : getLanguages(psiFile)) {
    StructureViewBuilder builder = getBuilder(psiFile, language);
    if (!(builder instanceof TreeBasedStructureViewBuilder)) continue;
    StructureViewModel model = ((TreeBasedStructureViewBuilder)builder).createStructureViewModel(editor);
    String title = language.getDisplayName();
    Image icon = ObjectUtils.notNull(LanguageUtil.getLanguageFileType(language), UnknownFileType.INSTANCE).getIcon();
    viewDescriptors.add(new StructureViewComposite.StructureViewDescriptor(title, model, icon));
  }
  return new StructureViewCompositeModel(psiFile, editor, viewDescriptors);
}
 

@Override
public StructureViewBuilder getStructureViewBuilder() {
  VirtualFile file = FileDocumentManager.getInstance().getFile(myEditor.getDocument());
  if (file == null) return null;

  final Project project = myEditor.getProject();
  LOG.assertTrue(project != null);
  return StructureViewBuilder.PROVIDER.getStructureViewBuilder(file.getFileType(), file, project);
}
 

@Override
public StructureViewBuilder getStructureViewBuilder() {
  Document document = myComponent.getEditor().getDocument();
  VirtualFile file = FileDocumentManager.getInstance().getFile(document);
  if (file == null || !file.isValid()) return null;
  return StructureViewBuilder.PROVIDER.getStructureViewBuilder(file.getFileType(), file, myProject);
}
 

@Nullable
public StructureViewBuilder getStructureViewBuilder(PsiFile file) {
  PsiStructureViewFactory factory = forLanguage(file.getLanguage());
  if (factory != null) {
    return factory.getStructureViewBuilder(file);
  }
  return null;
}
 

private static void addNavigationElements(Collection<PsiElement> array, PsiFile element) {
  StructureViewBuilder structureViewBuilder = LanguageStructureViewBuilder.INSTANCE.getStructureViewBuilder(element);
  if (structureViewBuilder instanceof TreeBasedStructureViewBuilder) {
    TreeBasedStructureViewBuilder builder = (TreeBasedStructureViewBuilder) structureViewBuilder;
    StructureViewModel model = builder.createStructureViewModel(null);
    try {
      addStructureViewElements(model.getRoot(), array, element);
    }
    finally {
      model.dispose();
    }
  }
}
 

public StructureViewBuilder getStructureViewBuilder(@NotNull final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {

        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(Editor editor) {
            return new GLSLStructureViewModel(psiFile);
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(@NotNull PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public com.intellij.ide.structureView.StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new StructureViewModel(psiFile);
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new WeaveStructureViewModel(psiFile, editor, new WeaveDocumentStructureView((WeaveFile) psiFile));
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    final FusionFile fusionFile = (FusionFile) psiFile;
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new FusionStructureViewModel(editor, fusionFile);
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(PsiFile psiFile) {
    ElmFile elmFile = (ElmFile) psiFile;
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new ElmStructureViewModel(elmFile);
        }
    };
}
 

@Override
@Nullable
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  if (!(psiFile instanceof BuildFile)) {
    return null;
  }
  return new TreeBasedStructureViewBuilder() {
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new BuildStructureViewModel((BuildFile) psiFile, editor);
    }
  };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(@NotNull PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new GraphQLStructureViewModel(psiFile, editor);
        }

        public boolean isRootNodeShown() {
            return false;
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new JSGraphQLEndpointStructureViewModel(psiFile, editor);
        }

        public boolean isRootNodeShown() {
            return false;
        }
    };
}
 

@Nullable
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return createStructureViewModel(); // todo, new api Idea 14.1
    }

    public StructureViewModel createStructureViewModel() {
      return new CppStructureViewBuilder(psiFile);
    }
  };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
	return new TreeBasedStructureViewBuilder() {
		@NotNull
		@Override
		public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
			return new SampleStructureViewModel((SamplePSIFileRoot)psiFile);
		}
	};
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(@NotNull final PsiFile psiFile) {
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new SimpleStructureViewModel(psiFile);
    }
  };
}